JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitable;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonschema.SchemaAware;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.ResolvableSerializer;
import com.fasterxml.jackson.databind.util.Converter;
import java.io.IOException;
import java.lang.reflect.Type;
/**
* Serializer implementation where given Java type is first converted
* to an intermediate "delegate type" (using a configured
* {@link Converter}, and then this delegate value is serialized by Jackson.
*<p>
* Note that although types may be related, they must not be same; trying
* to do this will result in an exception.
*
* @since 2.1
*/
@SuppressWarnings("serial")
public class StdDelegatingSerializer
extends StdSerializer<Object>
implements ContextualSerializer, ResolvableSerializer,
JsonFormatVisitable, SchemaAware
{
protected final Converter<Object,?> _converter;
/**
* Fully resolved delegate type, with generic information if any available.
*/
protected final JavaType _delegateType;
/**
* Underlying serializer for type <code>T<.code>.
*/
protected final JsonSerializer<Object> _delegateSerializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@SuppressWarnings("unchecked")
public StdDelegatingSerializer(Converter<?,?> converter)
{
super(Object.class);
_converter = (Converter<Object,?>)converter;
_delegateType = null;
_delegateSerializer = null;
}
@SuppressWarnings("unchecked")
public <T> StdDelegatingSerializer(Class<T> cls, Converter<T,?> converter)
{
super(cls, false);
_converter = (Converter<Object,?>)converter;
_delegateType = null;
_delegateSerializer = null;
}
@
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>SuppressWarnings("unchecked")
public StdDelegatingSerializer(Converter<Object,?> converter,
JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
super(delegateType);
_converter = converter;
_delegateType = delegateType;
_delegateSerializer = (JsonSerializer<Object>) delegateSerializer;
}
/**
* Method used for creating resolved contextual instances. Must be
* overridden when sub-classing.
*/
protected StdDelegatingSerializer withDelegate(Converter<Object,?> converter,
JavaType delegateType, JsonSerializer<?> delegateSerializer)
{
if (getClass() != StdDelegatingSerializer.class) {
throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'");
}
return new StdDelegatingSerializer(converter, delegateType, delegateSerializer);
}
/*
/**********************************************************
/* Contextualization
/**********************************************************
*/
@Override
public void resolve(SerializerProvider provider) throws JsonMappingException
{
if ((_delegateSerializer != null)
return ((SchemaAware) _delegateSerializer).getSchema(provider, typeHint);
}
return super.getSchema(provider, typeHint);
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>handledType.isEnum()) {
switch (shape) {
case STRING:
case NUMBER:
case NUMBER_INT:
// 12-Oct-2014, tatu: May need to introspect full annotations... but
// for now, just do class ones
BeanDescription desc = config.introspectClassAnnotations(_handledType);
JsonSerializer<?> ser = EnumSerializer.construct(_handledType,
provider.getConfig(), desc, format);
return provider.handlePrimaryContextualization(ser, property);
}
}
}
}
}
ObjectIdWriter oiw = _objectIdWriter;
String[] ignorals = null;
Object newFilterId = null;
// Then we may have an override for Object Id
if (accessor != null) {
ignorals = intr.findPropertiesToIgnore(accessor);
ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor);
if (objectIdInfo == null) {
// no ObjectId override, but maybe ObjectIdRef?
if (oiw != null) {
objectIdInfo = intr.findObjectReferenceInfo(accessor,
new ObjectIdInfo(NAME_FOR_OBJECT_REF, null, null, null));
oiw = _objectIdWriter.withAlwaysAsId(objectIdInfo.getAlwaysAsId());
}
} else {
/* Ugh: mostly copied from BeanSerializerBase: but can't easily
* change it to be able to move to SerializerProvider (where it
* really belongs)
*/
// 2.1: allow modifications by "id ref" annotations as well:
objectIdInfo = intr.findObjectReferenceInfo(accessor, objectIdInfo);
ObjectIdGenerator<?> gen;
Class<?> implClass = objectIdInfo.getGeneratorType();
JavaType type = provider.constructType(implClass);
JavaType idType = provider.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
// Property-based generator is trickier
if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work
String propName = objectIdInfo.getPropertyName().getSimpleName();
BeanPropertyWriter idProp = null;
for (int i = 0, len = _props.length ;; ++i) {
if (i == len) {
throw new IllegalArgumentException("Invalid Object Id
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> JsonGenerationException
{
/* note: almost verbatim copy of "serializeFields"; copied (instead of merged)
* so that old method need not add check for existence of filter.
*/
final BeanPropertyWriter[] props;
if (_filteredProps != null && provider.getActiveView() != null) {
props = _filteredProps;
} else {
props = _props;
}
final PropertyFilter filter = findPropertyFilter(provider, _propertyFilterId, bean);
// better also allow missing filter actually..
if (filter == null) {
serializeFields(bean, jgen, provider);
return;
}
int i = 0;
try {
for (final int len = props.length; i < len; ++i) {
BeanPropertyWriter prop = props[i];
if (prop != null) { // can have nulls in filtered list
filter.serializeAsField(bean, jgen, provider, prop);
}
}
if (_anyGetterWriter != null) {
_anyGetterWriter.getAndFilter(bean, jgen, provider, filter);
}
} catch (Exception e) {
String name = (i == props.length) ? "[anySetter]" : props[i].getName();
wrapAndThrow(provider, e, bean, name);
} catch (StackOverflowError e) {
JsonMappingException mapE = new JsonMappingException("Infinite recursion (StackOverflowError)", e);
String name = (i == props.length) ? "[anySetter]" : props[i].getName();
mapE.prependPath(new JsonMappingException.Reference(bean, name));
throw mapE;
}
}
@Deprecated
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
ObjectNode o = createSchemaNode("object", true);
// [JACKSON-813]: Add optional JSON Schema id attribute, if found
// NOTE: not optimal, does NOT go through AnnotationIntrospector etc:
JsonSerializableSchema ann = _handledType.getAnnotation(JsonSerializableSchema.class);
if (ann != null) {
String id = ann.id();
if (id != null && id.length() > 0) {
o.put("id", id);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind;
import java.lang.reflect.Modifier;
import com.fasterxml.jackson.core.type.ResolvedType;
import com.fasterxml.jackson.databind.type.TypeFactory;
/**
* Base class for type token classes used both to contain information
* and as keys for deserializers.
*<p>
* Instances can (only) be constructed by
* <code>com.fasterxml.jackson.databind.type.TypeFactory</code>.
*<p>
* Since 2.2 this implements {@link java.lang.reflect.Type} to allow
* it to be pushed through interfaces that only expose that type.
*/
public abstract class JavaType
extends ResolvedType
implements java.io.Serializable, // 2.1
java.lang.reflect.Type // 2.2
{
private static final long serialVersionUID = 1;
/**
* This is the nominal type-erased Class that would be close to the
* type represented (but not exactly type, due to type erasure: type
* instance may have more information on this).
* May be an interface or abstract class, so instantiation
* may not be possible.
*/
protected final Class<?> _class;
protected final int _hash;
/**
* Optional handler (codec) that can be attached to indicate
* what to use for handling (serializing, deserializing) values of
* this specific type.
*<p>
* Note: untyped (i.e. caller has to cast) because it is used for
* different kinds of handlers, with unrelated types.
*/
protected final Object _valueHandler;
/**
* Optional handler that can be attached to indicate how to handle
* additional type metadata associated with this type.
*<p>
* Note: untyped (i.e. caller has to cast) because it is used for
* different kinds of handlers, with unrelated types.
*/
protected final Object _typeHandler;
/**
* Whether entities defined with this type should be handled using
* static typing (as opposed to dynamic runtime type) or not.
*
* @since 2.2
*/
protected final boolean _asStatic;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* @param raw "
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Raw" (type-erased) class for this type
* @param additionalHash Additional hash code to use, in addition
* to hash code of the class name
*/
protected JavaType(Class<?> raw, int additionalHash,
Object valueHandler, Object typeHandler, boolean asStatic)
{
_class = raw;
_hash = raw.getName().hashCode() + additionalHash;
_valueHandler = valueHandler;
_typeHandler = typeHandler;
_asStatic = asStatic;
}
/**
* "Copy method" that will construct a new instance that is identical to
* this instance, except that it will have specified type handler assigned.
*
* @return Newly created type instance
*/
public abstract JavaType withTypeHandler(Object h);
/**
* "Copy method" that will construct a new instance that is identical to
* this instance, except that its content type will have specified
* type handler assigned.
*
* @return Newly created type instance
*/
public abstract JavaType withContentTypeHandler(Object h);
/**
* "Copy method" that will construct a new instance that is identical to
* this instance, except that it will have specified value handler assigned.
*
* @return Newly created type instance
*/
public abstract JavaType withValueHandler(Object h);
/**
* "Copy method" that will construct a new instance that is identical to
* this instance, except that it will have specified content value handler assigned.
*
* @return Newly created type instance
*/
public abstract JavaType withContentValueHandler(Object h);
/**
* Method that can be called to get a type instance that indicates
* that values of the type should be handled using "static typing" for purposes
* of serialization (as opposed to "dynamic" aka runtime typing):
* meaning that no runtime information is needed for determining serializers to use.
* The main use case is to allow forcing of specific root value serialization type,
* and specifically in resolving serializers for contained types (element types
* for arrays, Collections and Maps).
*
* @since 2.2
*/
public abstract JavaType withStaticTyping();
/*
/**********************************************************
/* Type coercion fluent factory methods
/**********************************************************
*/
/**
* Method that can be called to do a "narrow
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>ing" conversions; that is,
* to return a type with a raw class that is assignable to the raw
* class of this type. If this is not possible, an
* {@link IllegalArgumentException} is thrown.
* If class is same as the current raw class, instance itself is
* returned.
*/
public JavaType narrowBy(Class<?> subclass)
{
// First: if same raw class, just return this instance
if (subclass == _class) { return this; }
// Otherwise, ensure compatibility
_assertSubclass(subclass, _class);
JavaType result = _narrow(subclass);
// TODO: these checks should NOT actually be needed; above should suffice:
if (_valueHandler != result.<Object>getValueHandler()) {
result = result.withValueHandler(_valueHandler);
}
if (_typeHandler != result.<Object>getTypeHandler()) {
result = result.withTypeHandler(_typeHandler);
}
return result;
}
/**
* More efficient version of {@link #narrowBy}, called by
* internal framework in cases where compatibility checks
* are to be skipped.
*/
public JavaType forcedNarrowBy(Class<?> subclass)
{
if (subclass == _class) { // can still optimize for simple case
return this;
}
JavaType result = _narrow(subclass);
// TODO: these checks should NOT actually be needed; above should suffice:
if (_valueHandler != result.<Object>getValueHandler()) {
result = result.withValueHandler(_valueHandler);
}
if (_typeHandler != result.<Object>getTypeHandler()) {
result = result.withTypeHandler(_typeHandler);
}
return result;
}
/**
* Method that can be called to do a "widening" conversions; that is,
* to return a type with a raw class that could be assigned from this
* type.
* If such conversion is not possible, an
* {@link IllegalArgumentException} is thrown.
* If class is same as the current raw class, instance itself is
* returned.
*/
public JavaType widenBy(Class<?> superclass) {
// First: if same raw class, just return this instance
if (superclass == _class) { return this; }
// Otherwise, ensure compatibility
_assertSubclass(_class, superclass);
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> _widen(superclass);
}
protected abstract JavaType _narrow(Class<?> subclass);
/**
*<p>
* Default implementation is just to call {@link #_narrow}, since
* underlying type construction is usually identical
*/
protected JavaType _widen(Class<?> superclass) { return _narrow(superclass); }
public abstract JavaType narrowContentsBy(Class<?> contentClass);
public abstract JavaType widenContentsBy(Class<?> contentClass);
/*
/**********************************************************
/* Implementation of ResolvedType API
/**********************************************************
*/
@Override
public final Class<?> getRawClass() { return _class; }
/**
* Method that can be used to check whether this type has
* specified Class as its type erasure. Put another way, returns
* true if instantiation of this Type is given (type-erased) Class.
*/
@Override
public final boolean hasRawClass(Class<?> clz) { return _class == clz; }
@Override
public boolean isAbstract() {
return Modifier.isAbstract(_class.getModifiers());
}
/**
* Convenience method for checking whether underlying Java type
* is a concrete class or not: abstract classes and interfaces
* are not.
*/
@Override
public boolean isConcrete() {
int mod = _class.getModifiers();
if ((mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0) {
return true;
}
/* 19-Feb-2010, tatus: Holy mackarel; primitive types
* have 'abstract' flag set...
*/
return _class.isPrimitive();
}
@Override
public boolean isThrowable() { return Throwable.class.isAssignableFrom(_class); }
@Override
public boolean isArrayType() { return false; }
@Override
public final boolean isEnumType() { return _class.isEnum(); }
@Override
public final boolean isInterface() { return _class.isInterface(); }
@Override
public final boolean isPrimitive() { return _class.isPrimitive(); }
@Override
public final boolean isFinal() { return Modifier.isFinal(_class.getModifiers()); }
/**
* @return True if type represented is a container type; this includes
* array, Map and Collection types.
*/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> String toCanonical();
/**
* Method for accessing signature that contains generic
* type information, in form compatible with JVM 1.5
* as per JLS. It is a superset of {@link #getErasedSignature},
* in that generic information can be automatically removed
* if necessary (just remove outermost
* angle brackets along with content inside)
*/
public String getGenericSignature() {
StringBuilder sb = new StringBuilder(40);
getGenericSignature(sb);
return sb.toString();
}
/**
*
* @param sb StringBuilder to append signature to
*
* @return StringBuilder that was passed in; returned to allow
* call chaining
*/
public abstract StringBuilder getGenericSignature(StringBuilder sb);
/**
* Method for accessing signature without generic
* type information, in form compatible with all versions
* of JVM, and specifically used for type descriptions
* when generating byte code.
*/
public String getErasedSignature() {
StringBuilder sb = new StringBuilder(40);
getErasedSignature(sb);
return sb.toString();
}
/**
* Method for accessing signature without generic
* type information, in form compatible with all versions
* of JVM, and specifically used for type descriptions
* when generating byte code.
*
* @param sb StringBuilder to append signature to
*
* @return StringBuilder that was passed in; returned to allow
* call chaining
*/
public abstract StringBuilder getErasedSignature(StringBuilder sb);
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
protected void _assertSubclass(Class<?> subclass, Class<?> superClass) {
if (!_class.isAssignableFrom(subclass)) {
throw new IllegalArgumentException("Class "+subclass.getName()+" is not assignable to "+_class.getName());
}
}
/*
/**********************************************************
/* Standard methods; let's make them abstract to force override
/**********************************************************
*/
@Override
public abstract String toString();
@Override
public abstract boolean equals(Object o);
@Override
public final int hashCode() { return _hash; }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * we want to check if a type is a bean after some of "standard" JDK
* types, but before the rest.
* As a result, "mixed" delegation used, and calls are NOT done using
* regular {@link SerializerFactory} interface but rather via
* direct calls to {@link BasicSerializerFactory}.
*<p>
* Finally, since all caching is handled by the serializer provider
* (not factory) and there is no configurability, this
* factory is stateless.
* This means that a global singleton instance can be used.
*/
public class BeanSerializerFactory
extends BasicSerializerFactory
implements java.io.Serializable // since 2.1
{
private static final long serialVersionUID = 1;
/**
* Like {@link BasicSerializerFactory}, this factory is stateless, and
* thus a single shared global (== singleton) instance can be used
* without thread-safety issues.
*/
public final static BeanSerializerFactory instance = new BeanSerializerFactory(null);
/*
/**********************************************************
/* Life-cycle: creation, configuration
/**********************************************************
*/
/**
* Constructor for creating instances with specified configuration.
*/
protected BeanSerializerFactory(SerializerFactoryConfig config)
{
super(config);
}
/**
* Method used by module registration functionality, to attach additional
* serializer providers into this serializer factory. This is typically
* handled by constructing a new instance with additional serializers,
* to ensure thread-safe access.
*/
@Override
public SerializerFactory withConfig(SerializerFactoryConfig config)
{
if (_factoryConfig == config) {
return this;
}
/* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor;
* and we pretty much have to here either choose between losing subtype instance
* when registering additional serializers, or losing serializers.
* Instead, let's actually just throw an error if this method is called when subtype
* has not properly overridden this method; this to indicate problem as soon as possible.
*/
if (getClass() != BeanSerializerFactory.class) {
throw new IllegalStateException("Subtype of BeanSerializerFactory ("+getClass().getName()
+") has not properly overridden method 'withAdditionalSerializers': can not instantiate subtype with "
+"additional
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> serializer definitions");
}
return new BeanSerializerFactory(config);
}
@Override
protected Iterable<Serializers> customSerializers() {
return _factoryConfig.serializers();
}
/*
/**********************************************************
/* SerializerFactory impl
/**********************************************************
*/
/**
* Main serializer constructor method. We will have to be careful
* with respect to ordering of various method calls: essentially
* we want to reliably figure out which classes are standard types,
* and which are beans. The problem is that some bean Classes may
* implement standard interfaces (say, {@link java.lang.Iterable}.
*<p>
* Note: sub-classes may choose to complete replace implementation,
* if they want to alter priority of serializer lookups.
*/
@Override
@SuppressWarnings("unchecked")
public JsonSerializer<Object> createSerializer(SerializerProvider prov,
JavaType origType)
throws JsonMappingException
{
// Very first thing, let's check if there is explicit serializer annotation:
final SerializationConfig config = prov.getConfig();
BeanDescription beanDesc = config.introspect(origType);
JsonSerializer<?> ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
if (ser != null) {
return (JsonSerializer<Object>) ser;
}
boolean staticTyping;
// Next: we may have annotations that further define types to use...
JavaType type = modifyTypeByAnnotation(config, beanDesc.getClassInfo(), origType);
if (type == origType) { // no changes, won't force static typing
staticTyping = false;
} else { // changes; assume static typing; plus, need to re-introspect if class differs
}
final SerializationConfig config = prov.getConfig();
// Container types differ from non-container types
// (note: called method checks for module-provided serializers)
if (type.isContainerType()) {
if (!staticTyping) {
staticTyping = usesStaticTyping(config, beanDesc, null);
// [Issue#23]: Need to figure out how to force passed parameterization
// to stick...
/*
if (property == null) {
JavaType t = origType.getContentType();
if (t != null && !t.hasRawClass(Object.class)) {
staticTyping = true;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> */
}
// 03-Aug-2012, tatu: As per [Issue#40], may require POJO serializer...
ser = buildContainerSerializer(prov, type, beanDesc, staticTyping);
// Will return right away, since called method does post-processing:
if (ser != null) {
return ser;
}
} else {
// Modules may provide serializers of POJO types:
for (Serializers serializers : customSerializers()) {
ser = serializers.findSerializer(config, type, beanDesc);
if (ser != null) {
break;
}
}
}
// Otherwise, we will check "primary types"; both marker types that
// indicate specific handling (JsonSerializable), or main types that have
// precedence over container types
if (ser == null) {
ser = findSerializerByLookup(type, config, beanDesc, staticTyping);
if (ser == null) {
ser = findSerializerByPrimaryType(prov, type, beanDesc, staticTyping);
if (ser == null) {
// And this is where this class comes in: if type is not a
// known "primary JDK type", perhaps it's a bean? We can still
// get a null, if we can't find a single suitable bean property.
ser = findBeanSerializer(prov, type, beanDesc);
// Finally: maybe we can still deal with it as an implementation of some basic JDK interface?
if (ser == null) {
ser = findSerializerByAddonType(config, type, beanDesc, staticTyping);
// 18-Sep-2014, tatu: Actually, as per [jackson-databind#539], need to get
// 'unknown' serializer assigned earlier, here, so that it gets properly
// post-processed
if (ser == null) {
ser = prov.getUnknownTypeSerializer(beanDesc.getBeanClass());
}
}
}
}
}
if (ser != null) {
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifySerializer(config, beanDesc, ser);
}
}
}
return ser;
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> one is needed; null if not.
*/
public TypeSerializer findPropertyContentTypeSerializer(JavaType containerType,
SerializationConfig config, AnnotatedMember accessor)
throws JsonMappingException
{
JavaType contentType = containerType.getContentType();
AnnotationIntrospector ai = config.getAnnotationIntrospector();
TypeResolverBuilder<?> b = ai.findPropertyContentTypeResolver(config, accessor, containerType);
// Defaulting: if no annotations on member, check value class
if (b == null) {
return createTypeSerializer(config, contentType);
}
Collection<NamedType> subtypes = config.getSubtypeResolver().collectAndResolveSubtypes(accessor,
config, ai, contentType);
return b.buildTypeSerializer(config, contentType, subtypes);
}
/*
/**********************************************************
/* Overridable non-public factory methods
/**********************************************************
*/
/**
* Method called to construct serializer for serializing specified bean type.
*
* @since 2.1
*/
@SuppressWarnings("unchecked")
protected JsonSerializer<Object> constructBeanSerializer(SerializerProvider prov,
BeanDescription beanDesc)
throws JsonMappingException
{
// 13-Oct-2010, tatu: quick sanity check: never try to create bean serializer for plain Object
// 05-Jul-2012, tatu: ... but we should be able to just return "unknown type" serializer, right?
if (beanDesc.getBeanClass() == Object.class) {
return prov.getUnknownTypeSerializer(Object.class);
// throw new IllegalArgumentException("Can not create bean serializer for Object.class");
}
final SerializationConfig config = prov.getConfig();
BeanSerializerBuilder builder = constructBeanSerializerBuilder(beanDesc);
builder.setConfig(config);
// First: any detectable (auto-detect, annotations) properties to serialize?
List<BeanPropertyWriter> props = findBeanProperties(prov, beanDesc, builder);
if (props == null) {
props = new ArrayList<BeanPropertyWriter>();
}
// [databind#638]: Allow injection of "virtual" properties:
prov.getAnnotationIntrospector().findAndAddVirtualProperties(config, beanDesc.getClassInfo(), props);
// [JACKSON-440] Need to allow modification bean properties to
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, PropertyMetadata.STD_OPTIONAL);
builder.setAnyGetter(new AnyGetterWriter(anyProp, anyGetter, anySer));
}
// Next: need to gather view information, if any:
processViews(config, builder);
// Finally: let interested parties mess with the result bit more...
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
builder = mod.updateBuilder(config, beanDesc, builder);
}
}
JsonSerializer<Object> ser = (JsonSerializer<Object>) builder.build();
if (ser == null) {
// If we get this far, there were no properties found, so no regular BeanSerializer
// would be constructed. But, couple of exceptions.
// First: if there are known annotations, just create 'empty bean' serializer
if (beanDesc.hasKnownClassAnnotations()) {
return builder.createDummy();
}
}
return ser;
}
protected ObjectIdWriter constructObjectIdHandler(SerializerProvider prov,
BeanDescription beanDesc, List<BeanPropertyWriter> props)
throws JsonMappingException
{
ObjectIdInfo objectIdInfo = beanDesc.getObjectIdInfo();
if (objectIdInfo == null) {
return null;
}
ObjectIdGenerator<?> gen;
Class<?> implClass = objectIdInfo.getGeneratorType();
// Just one special case: Property-based generator is trickier
if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work
String propName = objectIdInfo.getPropertyName().getSimpleName();
BeanPropertyWriter idProp = null;
for (int i = 0, len = props.size() ;; ++i) {
if (i == len) {
throw new IllegalArgumentException("Invalid Object Id definition for "+beanDesc.getBeanClass().getName()
+": can not find property with name '"+propName+"'");
}
BeanPropertyWriter prop = props.get(i);
if (propName.equals(prop.getName())) {
idProp = prop;
/* Let's force it to be the first property to output
* (although it may still get rearranged etc)
*/
if (i > 0) {
props.remove(i);
props.add(0, idProp);
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> break;
}
}
JavaType idType = idProp.getType();
gen = new PropertyBasedObjectIdGenerator(objectIdInfo, idProp);
// one more thing: must ensure that ObjectIdWriter does not actually write the value:
return ObjectIdWriter.construct(idType, (PropertyName) null, gen, objectIdInfo.getAlwaysAsId());
}
// other types are simpler
JavaType type = prov.constructType(implClass);
// Could require type to be passed explicitly, but we should be able to find it too:
JavaType idType = prov.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
gen = prov.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo);
return ObjectIdWriter.construct(idType, objectIdInfo.getPropertyName(), gen,
objectIdInfo.getAlwaysAsId());
}
/**
* Method called to construct a filtered writer, for given view
* definitions. Default implementation constructs filter that checks
* active view type to views property is to be included in.
*/
protected BeanPropertyWriter constructFilteredBeanWriter(BeanPropertyWriter writer,
Class<?>[] inViews)
{
return FilteredBeanPropertyWriter.constructViewBased(writer, inViews);
}
protected PropertyBuilder constructPropertyBuilder(SerializationConfig config,
BeanDescription beanDesc)
{
return new PropertyBuilder(config, beanDesc);
}
protected BeanSerializerBuilder constructBeanSerializerBuilder(BeanDescription beanDesc) {
return new BeanSerializerBuilder(beanDesc);
}
/*
/**********************************************************
/* Overridable non-public introspection methods
/**********************************************************
*/
/**
* Helper method used to skip processing for types that we know
* can not be (i.e. are never consider to be) beans:
* things like primitives, Arrays, Enums, and proxy types.
*<p>
* Note that usually we shouldn't really be getting these sort of
* types anyway; but better safe than sorry.
*/
protected boolean isPotentialBeanType(Class<?> type)
{
return (ClassUtil.canBeABeanType(type) == null) && !ClassUtil.isProxyType(type);
}
/**
* Method used to collect all actual serializable properties.
* Can be overridden to implement custom detection schemes.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
/**
* For now, File objects get serialized by just outputting
* absolute (but not canonical) name as String value
*/
@SuppressWarnings("serial")
public class FileSerializer
extends StdScalarSerializer<File>
{
public FileSerializer() { super(File.class); }
@Override
public void serialize(File value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(value.getAbsolutePath());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
visitor.expectStringFormat(typeHint);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.net.InetAddress;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
/**
* Simple serializer for {@link java.net.InetAddress}. Main complexity is
* with registration, since same serializer is to be used for sub-classes.
*/
@SuppressWarnings("serial")
public class InetAddressSerializer
extends StdScalarSerializer<InetAddress>
{
public InetAddressSerializer() { super(InetAddress.class); }
@Override
public void serialize(InetAddress value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
// Ok: get textual description; choose "more specific" part
String str = value.toString().trim();
int ix = str.indexOf('/');
if (ix >= 0) {
if (ix == 0) { // missing host name; use address
str = str.substring(1);
} else { // otherwise use name
str = str.substring(0, ix);
}
}
jgen.writeString(str);
}
@Override
public void serializeWithType(InetAddress value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException
{
// Better ensure we don't use specific sub-classes...
typeSer.writeTypePrefixForScalar(value, jgen, InetAddress.class);
serialize(value, jgen, provider);
typeSer.writeTypeSuffixForScalar(value, jgen);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> usable, which may be
* the same event as the one it pointed to upon call).
*<p>
* Note that this method is never called for JSON null literal,
* and thus deserializers need (and should) not check for it.
*
* @param p Parsed used for reading JSON content
* @param ctxt Context that can be used to access information about
* this deserialization activity.
*
* @return Deserialized value
*/
public abstract T deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException, JsonProcessingException;
/**
* Alternate deserialization method (compared to the most commonly
* used, {@link #deserialize(JsonParser, DeserializationContext)}),
* which takes in initialized value instance, to be
* configured and/or populated by deserializer.
* Method is not necessarily used (or supported) by all types
* (it will not work for immutable types, for obvious reasons):
* most commonly it is used for Collections and Maps.
* It may be used both with "updating readers" (for POJOs) and
* when Collections and Maps use "getter as setter".
*<p>
* Default implementation just throws
* {@link UnsupportedOperationException}, to indicate that types
* that do not explicitly add support do not necessarily support
* update-existing-value operation (esp. immutable types)
*/
public T deserialize(JsonParser p, DeserializationContext ctxt,
T intoValue)
throws IOException, JsonProcessingException
{
throw new UnsupportedOperationException("Can not update object of type "
+intoValue.getClass().getName()+" (by deserializer of type "+getClass().getName()+")");
}
/**
* Deserialization called when type being deserialized is defined to
* contain additional type identifier, to allow for correctly
* instantiating correct subtype. This can be due to annotation on
* type (or its supertype), or due to global settings without
* annotations.
*<p>
* Default implementation may work for some types, but ideally subclasses
* should not rely on current default implementation.
* Implementation is mostly provided to avoid compilation errors with older
* code.
*
* @param typeDeserializer Deserializer to use for handling type information
*/
public Object deserializeWithType(JsonParser p, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> Some standard deserializers (most notably
* {@link com.fasterxml.jackson.databind.deser.BeanDeserializer})
* do implement this feature, and may return reader instance, depending on exact
* configuration of instance (which is based on type, and referring property).
*
* @return ObjectIdReader used for resolving possible Object Identifier
* value, instead of full value serialization, if deserializer can do that;
* null if no Object Id is expected.
*
* @since 2.0
*/
public ObjectIdReader getObjectIdReader() { return null; }
/**
* Accessor that can be used to determine if this deserializer uses
* another deserializer for actual deserialization, by delegating
* calls. If so, will return immediate delegate (which itself may
* delegate to further deserializers); otherwise will return null.
*
* @return Deserializer this deserializer delegates calls to, if null;
* null otherwise.
*
* @since 2.1
*/
public JsonDeserializer<?> getDelegatee() {
return null;
}
/**
* Method needed by {@link BeanDeserializerFactory} to properly link
* managed- and back-reference pairs.
*
* @since 2.2 (was moved out of <code>BeanDeserializerBase</code>)
*/
public SettableBeanProperty findBackReference(String refName)
{
throw new IllegalArgumentException("Can not handle managed/back reference '"+refName
+"': type: value deserializer of type "+getClass().getName()+" does not support them");
}
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* This marker class is only to be used with annotations, to
* indicate that <b>no deserializer is configured</b>.
*<p>
* Specifically, this class is to be used as the marker for
* annotation {@link com.fasterxml.jackson.databind.annotation.JsonDeserialize}
*/
public abstract static class None extends JsonDeserializer<Object> {
private None() { } // not to be instantiated
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.deser.ResolvableDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Deserializer implementation where given Java type is first deserialized
* by a standard Jackson deserializer into a delegate type; and then
* this delegate type is converted using a configured
* {@link Converter} into desired target type.
* Common delegate types to use are {@link java.util.Map}
* and {@link com.fasterxml.jackson.databind.JsonNode}.
*<p>
* Note that although types (delegate, target) may be related, they must not be same; trying
* to do this will result in an exception.
*<p>
* Since 2.5 There is {@link StdNodeBasedDeserializer} that is a simplified version
* for cases where intermediate type is {@link JsonNode}
*
* @param <T> Target type to convert to, from delegate type
*
* @since 2.1
*
* @see StdNodeBasedDeserializer
* @see Converter
*/
public class StdDelegatingDeserializer<T>
extends StdDeserializer<T>
implements ContextualDeserializer, ResolvableDeserializer
{
private static final long serialVersionUID = 1L;
protected final Converter<Object,T> _converter;
/**
* Fully resolved delegate type, with generic information if any available.
*/
protected final JavaType _delegateType;
/**
* Underlying serializer for type <code>T<.code>.
*/
protected final JsonDeserializer<Object> _delegateDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@SuppressWarnings("unchecked")
public StdDelegatingDeserializer(Converter<?,T> converter)
{
super(Object.class);
_converter = (Converter<Object,T>)converter;
_delegateType = null;
_delegateDeserializer = null;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
@SuppressWarnings("unchecked")
public StdDelegatingDeserializer(Converter<Object,T> converter,
JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
super(delegateType);
_converter = converter;
_delegateType = delegateType;
_delegateDeserializer = (JsonDeserializer<Object>) delegateDeserializer;
}
/**
* @since 2.5
*/
protected StdDelegatingDeserializer(StdDelegatingDeserializer<T> src)
{
super(src);
_converter = src._converter;
_delegateType = src._delegateType;
_delegateDeserializer = src._delegateDeserializer;
}
/**
* Method used for creating resolved contextual instances. Must be
* overridden when sub-classing.
*/
protected StdDelegatingDeserializer<T> withDelegate(Converter<Object,T> converter,
JavaType delegateType, JsonDeserializer<?> delegateDeserializer)
{
if (getClass() != StdDelegatingDeserializer.class) {
throw new IllegalStateException("Sub-class "+getClass().getName()+" must override 'withDelegate'");
}
return new StdDelegatingDeserializer<T>(converter, delegateType, delegateDeserializer);
}
/*
/**********************************************************
/* Contextualization
/**********************************************************
*/
@Override
public void resolve(DeserializationContext ctxt)
throws JsonMappingException
{
if (_delegateDeserializer != null && _delegateDeserializer instanceof ResolvableDeserializer) {
((ResolvableDeserializer) _delegateDeserializer).resolve(ctxt);
}
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property)
throws JsonMappingException
{
// First: if already got serializer to delegate to, contextualize it:
if (_delegateDeserializer != null) {
JsonDeserializer<?> deser = ctxt.handleSecondaryContextualization(_delegateDeserializer,
property, _delegateType);
if (deser != _delegateDeserializer) {
return withDelegate(_converter, _delegateType, deser);
}
return this;
}
// Otherwise: figure out what is the fully generic delegate type, then find deserializer
JavaType delegateType = _converter.getInputType(ctxt.getTypeFactory());
return withDelegate(_converter, delegateType,
ctxt.findContextualValueDeserializer(delegateType, property));
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public JsonDeserializer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.util.Iterator;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
import com.fasterxml.jackson.databind.ser.std.AsArraySerializerBase;
@SuppressWarnings("serial")
@JacksonStdImpl
public class IteratorSerializer
extends AsArraySerializerBase<Iterator<?>>
{
public IteratorSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts,
BeanProperty property)
{
super(Iterator.class, elemType, staticTyping, vts, property, null);
}
public IteratorSerializer(IteratorSerializer src,
BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer)
{
super(src, property, vts, valueSerializer);
}
@Override
public boolean isEmpty(SerializerProvider prov, Iterator<?> value) {
return (value == null) || !value.hasNext();
}
@Override
public boolean hasSingleElement(Iterator<?> value) {
// no really good way to determine (without consuming iterator), so:
return false;
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return new IteratorSerializer(_elementType, _staticTyping, vts, _property);
}
@Override
public IteratorSerializer withResolved(BeanProperty property,
TypeSerializer vts, JsonSerializer<?> elementSerializer) {
return new IteratorSerializer(this, property, vts, elementSerializer);
}
@Override
public final void serialize(Iterator<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(value)) {
serializeContents(value, jgen, provider);
return;
}
jgen.writeStartArray();
serializeContents(value, jgen, provider);
jgen.writeEndArray();
}
@Override
public void serializeContents(Iterator<?> value, JsonGenerator jgen, Serializer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Provider provider)
throws IOException
{
if (value.hasNext()) {
final TypeSerializer typeSer = _valueTypeSerializer;
JsonSerializer<Object> prevSerializer = null;
Class<?> prevClass = null;
do {
Object elem = value.next();
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
JsonSerializer<Object> currSerializer = _elementSerializer;
if (currSerializer == null) {
// Minor optimization to avoid most lookups:
Class<?> cc = elem.getClass();
if (cc == prevClass) {
currSerializer = prevSerializer;
} else {
currSerializer = provider.findValueSerializer(cc, _property);
prevSerializer = currSerializer;
prevClass = cc;
}
}
if (typeSer == null) {
currSerializer.serialize(elem, jgen, provider);
} else {
currSerializer.serializeWithType(elem, jgen, provider, typeSer);
}
} while (value.hasNext());
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> = findSerializationType(am, defaultUseStaticTyping, declaredType);
// Container types can have separate type serializers for content (value / element) type
if (contentTypeSer != null) {
/* 04-Feb-2010, tatu: Let's force static typing for collection, if there is
* type information for contents. Should work well (for JAXB case); can be
* revisited if this causes problems.
*/
if (serializationType == null) {
// serializationType = TypeFactory.type(am.getGenericType(), _beanDesc.getType());
serializationType = declaredType;
}
JavaType ct = serializationType.getContentType();
/* 03-Sep-2010, tatu: This is somehow related to [JACKSON-356], but I don't completely
* yet understand how pieces fit together. Still, better to be explicit than rely on
* NPE to indicate an issue...
*/
if (ct == null) {
throw new IllegalStateException("Problem trying to create BeanPropertyWriter for property '"
+propDef.getName()+"' (of type "+_beanDesc.getType()+"); serialization type "+serializationType+" has no content");
}
serializationType = serializationType.withContentTypeHandler(contentTypeSer);
ct = serializationType.getContentType();
}
Object valueToSuppress = null;
boolean suppressNulls = false;
JsonInclude.Include inclusion = propDef.findInclusion();
if (inclusion == null) {
inclusion = _defaultInclusion;
}
if (inclusion != null) {
switch (inclusion) {
case NON_DEFAULT:
valueToSuppress = getDefaultValue(propDef.getName(), am);
if (valueToSuppress == null) {
suppressNulls = true;
} else {
// [JACKSON-531]: Allow comparison of arrays too...
if (valueToSuppress.getClass().isArray()) {
valueToSuppress = ArrayBuilders.getArrayComparator(valueToSuppress);
}
}
break;
case NON_EMPTY:
// always suppress nulls
suppressNulls = true;
// but possibly also 'empty' values:
valueToSuppress = BeanPropertyWriter.MARKER_FOR_EMPTY;
break;
case NON_NULL:
suppressNull
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Member member)
{
Object defaultBean = getDefaultBean();
try {
return member.getValue(defaultBean);
} catch (Exception e) {
return _throwWrapped(e, name, defaultBean);
}
}
/*
/**********************************************************
/* Helper methods for exception handling
/**********************************************************
*/
protected Object _throwWrapped(Exception e, String propName, Object defaultBean)
{
Throwable t = e;
while (t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) throw (Error) t;
if (t instanceof RuntimeException) throw (RuntimeException) t;
throw new IllegalArgumentException("Failed to get property '"+propName+"' of default "+defaultBean.getClass().getName()+" instance");
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.lang.reflect.Method;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.EnumResolver;
/**
* Deserializer class that can deserialize instances of
* specified Enum class from Strings and Integers.
*/
public class EnumDeserializer
extends StdScalarDeserializer<Enum<?>>
{
private static final long serialVersionUID = 1L;
protected final EnumResolver<?> _resolver;
public EnumDeserializer(EnumResolver<?> res)
{
super(Enum.class);
_resolver = res;
}
/**
* Factory method used when Enum instances are to be deserialized
* using a creator (static factory method)
*
* @return Deserializer based on given factory method, if type was suitable;
* null if type can not be used
*/
public static JsonDeserializer<?> deserializerForCreator(DeserializationConfig config,
Class<?> enumClass, AnnotatedMethod factory)
{
// note: caller has verified there's just one arg; but we must verify its type
Class<?> paramClass = factory.getRawParameterType(0);
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(factory.getMember());
}
return new FactoryBasedDeserializer(enumClass, factory, paramClass);
}
/*
/**********************************************************
/* Default JsonDeserializer implementation
/**********************************************************
*/
/**
* Because of costs associated with constructing Enum resolvers,
* let's cache instances by default.
*/
@Override
public boolean isCachable() { return true; }
@Override
public Enum<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
JsonToken curr = jp.getCurrentToken();
// Usually should just get string value:
if (curr == JsonToken.VALUE_STRING || curr == JsonToken.FIELD_NAME) {
String name = jp.getText();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>();
// Issue#381
if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
jp.nextToken();
final Enum<?> parsed = deserialize(jp, ctxt);
curr = jp.nextToken();
if (curr != JsonToken.END_ARRAY) {
throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
"Attempted to unwrap single value array for single '" + _resolver.getEnumClass().getName() + "' value but there was more than a single value in the array");
}
return parsed;
}
throw ctxt.mappingException(_resolver.getEnumClass());
}
protected void _checkFailOnNumber(DeserializationContext ctxt) throws IOException
{
if (ctxt.isEnabled(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS)) {
throw ctxt.mappingException("Not allowed to deserialize Enum value out of JSON number (disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow)");
}
}
/*
/**********************************************************
/* Additional helper classes
/**********************************************************
*/
/**
* Deserializer that uses a single-String static factory method
* for locating Enum values by String id.
*/
protected static class FactoryBasedDeserializer
extends StdDeserializer<Object>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1;
// Marker type; null if String expected; otherwise numeric wrapper
protected final Class<?> _inputType;
protected final Method _factory;
protected final JsonDeserializer<?> _deser;
public FactoryBasedDeserializer(Class<?> cls, AnnotatedMethod f,
Class<?> inputType)
{
super(cls);
_factory = f.getAnnotated();
_inputType = inputType;
_deser = null;
}
protected FactoryBasedDeserializer(FactoryBasedDeserializer base,
JsonDeserializer<?> deser) {
super(base._valueClass);
_inputType = base._inputType;
_factory = base._factory;
_deser = deser;
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property)
throws JsonMappingException
{
if ((_deser == null) && (_inputType != String.class)) {
return new FactoryBased
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.*;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonFormat.Shape;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonStringFormatVisitor;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.util.EnumValues;
/**
* Standard serializer used for {@link java.lang.Enum} types.
*<p>
* Based on {@link StdScalarSerializer} since the JSON value is
* scalar (String).
*
* @author tatu
*/
@JacksonStdImpl
public class EnumSerializer
extends StdScalarSerializer<Enum<?>>
implements ContextualSerializer
{
private static final long serialVersionUID = 1L;
/**
* This map contains pre-resolved values (since there are ways
* to customize actual String constants to use) to use as
* serializations.
*/
protected final EnumValues _values;
/**
* Flag that is set if we statically know serialization choice
* between index and textual format (null if it needs to be dynamically
* checked).
*
* @since 2.1
*/
protected final Boolean _serializeAsIndex;
/*
/**********************************************************
/* Construction, initialization
/**********************************************************
*/
/**
* @deprecated Since 2.1
*/
@Deprecated
public EnumSerializer(EnumValues v) {
this(v, null);
}
public EnumSerializer(EnumValues v, Boolean serializeAsIndex)
{
super(Enum.class, false);
_
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import com.fasterxml.jackson.databind.JavaType;
/**
* Type that represents "true" Java Map types.
*/
public final class MapType extends MapLikeType
{
private static final long serialVersionUID = -811146779148281500L;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
private MapType(Class<?> mapType, JavaType keyT, JavaType valueT,
Object valueHandler, Object typeHandler, boolean asStatic) {
super(mapType, keyT, valueT, valueHandler, typeHandler, asStatic);
}
public static MapType construct(Class<?> rawType, JavaType keyT, JavaType valueT) {
// nominally component types will be just Object.class
return new MapType(rawType, keyT, valueT, null, null, false);
}
@Override
protected JavaType _narrow(Class<?> subclass) {
return new MapType(subclass, _keyType, _valueType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType narrowContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _valueType.getRawClass()) {
return this;
}
return new MapType(_class, _keyType, _valueType.narrowBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType widenContentsBy(Class<?> contentClass)
{
if (contentClass == _valueType.getRawClass()) {
return this;
}
return new MapType(_class, _keyType, _valueType.widenBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType narrowKey(Class<?> keySubclass)
{
// Can do a quick check first:
if (keySubclass == _keyType.getRawClass()) {
return this;
}
return new MapType(_class, _keyType.narrowBy(keySubclass), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType widenKey(Class
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS><?> keySubclass)
{
// Can do a quick check first:
if (keySubclass == _keyType.getRawClass()) {
return this;
}
return new MapType(_class, _keyType.widenBy(keySubclass), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapType withTypeHandler(Object h) {
return new MapType(_class, _keyType, _valueType, _valueHandler, h, _asStatic);
}
@Override
public MapType withContentTypeHandler(Object h)
{
return new MapType(_class, _keyType, _valueType.withTypeHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapType withValueHandler(Object h) {
return new MapType(_class, _keyType, _valueType, h, _typeHandler, _asStatic);
}
@Override
public MapType withContentValueHandler(Object h) {
return new MapType(_class, _keyType, _valueType.withValueHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapType withStaticTyping() {
if (_asStatic) {
return this;
}
return new MapType(_class, _keyType.withStaticTyping(), _valueType.withStaticTyping(),
_valueHandler, _typeHandler, true);
}
/*
/**********************************************************
/* Overridden accessors
/**********************************************************
*/
@Override
public Class<?> getParameterSource() {
return java.util.Map.class;
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
@Override
public MapType withKeyTypeHandler(Object h)
{
return new MapType(_class, _keyType.withTypeHandler(h), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapType withKeyValueHandler(Object h) {
return new MapType(_class, _keyType.withValueHandler(h), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public String toString()
{
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> "[map type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]";
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.math.BigInteger;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonNumberFormatVisitor;
/**
* As a fallback, we may need to use this serializer for other
* types of {@link Number}s: both custom types and "big" numbers
* like {@link BigInteger} and {@link BigDecimal}.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class NumberSerializer
extends StdScalarSerializer<Number>
{
/**
* Static instance that is only to be used for {@link java.lang.Number}.
*/
public final static NumberSerializer instance = new NumberSerializer(Number.class);
protected final boolean _isInt;
@Deprecated // since 2.5
public NumberSerializer() {
super(Number.class);
_isInt = false;
}
/**
* @since 2.5
*/
public NumberSerializer(Class<? extends Number> rawType) {
super(rawType, false);
// since this will NOT be constructed for Integer or Long, only case is:
_isInt = (rawType == BigInteger.class);
}
@Override
public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
// should mostly come in as one of these two:
if (value instanceof BigDecimal) {
jgen.writeNumber((BigDecimal) value);
} else if (value instanceof BigInteger) {
jgen.writeNumber((BigInteger) value);
/* These shouldn't match (as there are more specific ones),
* but just to be sure:
*/
} else if (value instanceof Integer) {
jgen.writeNumber(value.intValue());
} else if (value instanceof Long)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> {
jgen.writeNumber(value.longValue());
} else if (value instanceof Double) {
jgen.writeNumber(value.doubleValue());
} else if (value instanceof Float) {
jgen.writeNumber(value.floatValue());
} else if ((value instanceof Byte) || (value instanceof Short)) {
jgen.writeNumber(value.intValue()); // doesn't need to be cast to smaller numbers
} else {
// We'll have to use fallback "untyped" number write method
jgen.writeNumber(value.toString());
}
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode(_isInt ? "integer" : "number", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
if (_isInt) {
JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint);
if (v2 != null) {
v2.numberType(JsonParser.NumberType.BIG_INTEGER);
}
} else {
JsonNumberFormatVisitor v2 = visitor.expectNumberFormat(typeHint);
if (v2 != null) {
Class<?> h = handledType();
if (h == BigDecimal.class) {
v2.numberType(JsonParser.NumberType.BIG_DECIMAL);
} // otherwise it's for Number... anything we could do there?
}
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.exc;
import java.util.*;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.JsonMappingException;
/**
* Specialized {@link JsonMappingException} sub-class specifically used
* to indicate problems due to encountering a JSON property that could
* not be mapped to an Object property (via getter, constructor argument
* or field).
*/
public class UnrecognizedPropertyException
extends PropertyBindingException
{
private static final long serialVersionUID = 1L;
public UnrecognizedPropertyException(String msg, JsonLocation loc,
Class<?> referringClass, String propName,
Collection<Object> propertyIds)
{
super(msg, loc, referringClass, propName, propertyIds);
}
/**
* Factory method used for constructing instances of this exception type.
*
* @param jp Underlying parser used for reading input being used for data-binding
* @param fromObjectOrClass Reference to either instance of problematic type (
* if available), or if not, type itself
* @param propertyName Name of unrecognized property
* @param propertyIds (optional, null if not available) Set of properties that
* type would recognize, if completely known: null if set can not be determined.
*/
public static UnrecognizedPropertyException from(JsonParser jp,
Object fromObjectOrClass, String propertyName,
Collection<Object> propertyIds)
{
if (fromObjectOrClass == null) {
throw new IllegalArgumentException();
}
Class<?> ref;
if (fromObjectOrClass instanceof Class<?>) {
ref = (Class<?>) fromObjectOrClass;
} else {
ref = fromObjectOrClass.getClass();
}
String msg = "Unrecognized field \""+propertyName+"\" (class "+ref.getName()+"), not marked as ignorable";
UnrecognizedPropertyException e = new UnrecognizedPropertyException(msg,
jp.getCurrentLocation(), ref, propertyName, propertyIds);
// but let's also ensure path includes this last (missing) segment
e.prependPath(fromObjectOrClass, propertyName);
return e;
}
/**
* @deprecated Since 2.3, use {@link #getPropertyName} instead.
*/
@Deprecated
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.PropertyMetadata;
import com.fasterxml.jackson.databind.PropertyName;
import com.fasterxml.jackson.databind.deser.CreatorProperty;
import com.fasterxml.jackson.databind.deser.ValueInstantiator;
/**
* For {@link JsonLocation}, we should be able to just implement
* {@link ValueInstantiator} (not that explicit one would be very
* hard but...)
*/
public class JsonLocationInstantiator extends ValueInstantiator
{
@Override
public String getValueTypeDesc() {
return JsonLocation.class.getName();
}
@Override
public boolean canCreateFromObjectWith() { return true; }
@Override
public CreatorProperty[] getFromObjectArguments(DeserializationConfig config) {
JavaType intType = config.constructType(Integer.TYPE);
JavaType longType = config.constructType(Long.TYPE);
return new CreatorProperty[] {
creatorProp("sourceRef", config.constructType(Object.class), 0),
creatorProp("byteOffset", longType, 1),
creatorProp("charOffset", longType, 2),
creatorProp("lineNr", intType, 3),
creatorProp("columnNr", intType, 4)
};
}
private static CreatorProperty creatorProp(String name, JavaType type, int index) {
return new CreatorProperty(new PropertyName(name), type, null,
null, null, null, index, null, PropertyMetadata.STD_REQUIRED);
}
@Override
public Object createFromObjectWith(DeserializationContext ctxt, Object[] args) {
return new JsonLocation(args[0], _long(args[1]), _long(args[2]),
_int(args[3]), _int(args[4]));
}
private final static long _long(Object o) {
return (o == null) ? 0L : ((Number) o).longValue();
}
private final static int _int(Object o) {
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
ReadableObjectId entry = new ReadableObjectId(key);
entry.setResolver(resolver);
_objectIds.put(key, entry);
return entry;
}
@Deprecated // since 2.4
@Override
public ReadableObjectId findObjectId(Object id, ObjectIdGenerator<?> gen) {
return findObjectId(id, gen, new SimpleObjectIdResolver());
}
@Override
public void checkUnresolvedObjectId() throws UnresolvedForwardReference
{
if (_objectIds == null) {
return;
}
// 29-Dec-2014, tatu: As per [databind#299], may also just let unresolved refs be...
if (!isEnabled(DeserializationFeature.FAIL_ON_UNRESOLVED_OBJECT_IDS)) {
return;
}
UnresolvedForwardReference exception = null;
for (Entry<IdKey,ReadableObjectId> entry : _objectIds.entrySet()) {
ReadableObjectId roid = entry.getValue();
if (roid.hasReferringProperties()) {
if (exception == null) {
exception = new UnresolvedForwardReference("Unresolved forward references for: ");
}
for (Iterator<Referring> iterator = roid.referringProperties(); iterator.hasNext(); ) {
Referring referring = iterator.next();
exception.addUnresolvedId(roid.getKey().key, referring.getBeanType(), referring.getLocation());
}
}
}
if (exception != null) {
throw exception;
}
}
/*
/**********************************************************
/* Abstract methods impls, other factory methods
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public JsonDeserializer<Object> deserializerInstance(Annotated ann, Object deserDef)
throws JsonMappingException
{
if (deserDef == null) {
return null;
}
JsonDeserializer<?> deser;
if (deserDef instanceof JsonDeserializer) {
deser = (JsonDeserializer<?>) deserDef;
} else {
/* Alas, there's no way to force return type of "either class
* X or Y" -- need to throw an exception after the fact
*/
if (!(deserDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned deserializer definition of type "+deserDef.getClass().getName()+"; expected type JsonDeserializer or
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> Class<JsonDeserializer> instead");
}
Class<?> deserClass = (Class<?>)deserDef;
// there are some known "no class" markers to consider too:
if (deserClass == JsonDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) {
return null;
}
if (!JsonDeserializer.class.isAssignableFrom(deserClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName()+"; expected Class<JsonDeserializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
deser = (hi == null) ? null : hi.deserializerInstance(_config, ann, deserClass);
if (deser == null) {
deser = (JsonDeserializer<?>) ClassUtil.createInstance(deserClass,
_config.canOverrideAccessModifiers());
}
}
// First: need to resolve
if (deser instanceof ResolvableDeserializer) {
((ResolvableDeserializer) deser).resolve(this);
}
return (JsonDeserializer<Object>) deser;
}
@Override
public final KeyDeserializer keyDeserializerInstance(Annotated ann, Object deserDef)
throws JsonMappingException
{
if (deserDef == null) {
return null;
}
KeyDeserializer deser;
if (deserDef instanceof KeyDeserializer) {
deser = (KeyDeserializer) deserDef;
} else {
if (!(deserDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type "
+deserDef.getClass().getName()
+"; expected type KeyDeserializer or Class<KeyDeserializer> instead");
}
Class<?> deserClass = (Class<?>)deserDef;
// there are some known "no class" markers to consider too:
if (deserClass == KeyDeserializer.None.class || ClassUtil.isBogusClass(deserClass)) {
return null;
}
if (!KeyDeserializer.class.isAssignableFrom(deserClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "+deserClass.getName()
+"; expected Class<KeyDeserializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
deser = (hi == null) ? null : hi.keyDeserializerInstance(_config, ann, deserClass);
if
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> (deser == null) {
deser = (KeyDeserializer) ClassUtil.createInstance(deserClass,
_config.canOverrideAccessModifiers());
}
}
// First: need to resolve
if (deser instanceof ResolvableDeserializer) {
((ResolvableDeserializer) deser).resolve(this);
}
return deser;
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Fluent factory method used for constructing a blueprint instance
* with different factory
*/
public abstract DefaultDeserializationContext with(DeserializerFactory factory);
/**
* Method called to create actual usable per-deserialization
* context instance.
*/
public abstract DefaultDeserializationContext createInstance(
DeserializationConfig config, JsonParser jp, InjectableValues values);
/*
/**********************************************************
/* And then the concrete implementation class
/**********************************************************
*/
/**
* Actual full concrete implementation
*/
public final static class Impl extends DefaultDeserializationContext
{
private static final long serialVersionUID = 1L;
/**
* Default constructor for a blueprint object, which will use the standard
* {@link DeserializerCache}, given factory.
*/
public Impl(DeserializerFactory df) {
super(df, null);
}
protected Impl(Impl src,
DeserializationConfig config, JsonParser jp, InjectableValues values) {
super(src, config, jp, values);
}
protected Impl(Impl src) { super(src); }
protected Impl(Impl src, DeserializerFactory factory) {
super(src, factory);
}
@Override
public DefaultDeserializationContext copy() {
if (getClass() != Impl.class) {
return super.copy();
}
return new Impl(this);
}
@Override
public DefaultDeserializationContext createInstance(DeserializationConfig config,
JsonParser jp, InjectableValues values) {
return new Impl(this, config, jp, values);
}
@Override
public DefaultDeserializationContext with(DeserializerFactory factory) {
return new Impl(this, factory);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> prop = it.next();
if (prop.getName().equals(propName)) {
it.remove();
return true;
}
}
return false;
}
/*
/**********************************************************
/* Simple accessors from BeanDescription
/**********************************************************
*/
@Override
public AnnotatedClass getClassInfo() { return _classInfo; }
@Override
public ObjectIdInfo getObjectIdInfo() { return _objectIdInfo; }
@Override
public List<BeanPropertyDefinition> findProperties() {
return _properties;
}
@Override
public AnnotatedMethod findJsonValueMethod() {
return _jsonValueMethod;
}
@Override
public Set<String> getIgnoredPropertyNames() {
if (_ignoredPropertyNames == null) {
return Collections.emptySet();
}
return _ignoredPropertyNames;
}
@Override
public boolean hasKnownClassAnnotations() {
return _classInfo.hasAnnotations();
}
@Override
public Annotations getClassAnnotations() {
return _classInfo.getAnnotations();
}
@Override
public TypeBindings bindingsForBeanType()
{
if (_bindings == null) {
_bindings = new TypeBindings(_config.getTypeFactory(), _type);
}
return _bindings;
}
@Override
public JavaType resolveType(java.lang.reflect.Type jdkType) {
if (jdkType == null) {
return null;
}
return bindingsForBeanType().resolveType(jdkType);
}
@Override
public AnnotatedConstructor findDefaultConstructor() {
return _classInfo.getDefaultConstructor();
}
@Override
public AnnotatedMethod findAnySetter() throws IllegalArgumentException
{
if (_anySetterMethod != null) {
/* Also, let's be somewhat strict on how field name is to be
* passed; String, Object make sense, others not
* so much.
*/
/* !!! 18-May-2009, tatu: how about enums? Can add support if
* requested; easy enough for devs to add support within
* method.
*/
Class<?> type = _anySetterMethod.getRawParameterType(0);
if (type != String.class && type != Object.class) {
throw new IllegalArgumentException("Invalid 'any-setter' annotation on method "+_anySetterMethod.getName()+"
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(): first argument not of type String or Object, but "+type.getName());
}
}
return _anySetterMethod;
}
@Override
public Map<Object, AnnotatedMember> findInjectables() {
return _injectables;
}
@Override
public List<AnnotatedConstructor> getConstructors() {
return _classInfo.getConstructors();
}
@Override
public Object instantiateBean(boolean fixAccess)
{
AnnotatedConstructor ac = _classInfo.getDefaultConstructor();
if (ac == null) {
return null;
}
if (fixAccess) {
ac.fixAccess();
}
try {
return ac.getAnnotated().newInstance();
} catch (Exception e) {
Throwable t = e;
while (t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) throw (Error) t;
if (t instanceof RuntimeException) throw (RuntimeException) t;
throw new IllegalArgumentException("Failed to instantiate bean of type "+_classInfo.getAnnotated().getName()+": ("+t.getClass().getName()+") "+t.getMessage(), t);
}
}
/*
/**********************************************************
/* Simple accessors, extended
/**********************************************************
*/
@Override
public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes) {
return _classInfo.findMethod(name, paramTypes);
}
/*
/**********************************************************
/* General per-class annotation introspection
/**********************************************************
*/
@Override
public JsonFormat.Value findExpectedFormat(JsonFormat.Value defValue)
{
if (_annotationIntrospector != null) {
JsonFormat.Value v = _annotationIntrospector.findFormat(_classInfo);
if (v != null) {
return v;
}
}
return defValue;
}
/*
/**********************************************************
/* Introspection for serialization
/**********************************************************
*/
@Override
public Converter<Object,Object> findSerializationConverter()
{
if (_annotationIntrospector == null) {
return null;
}
return _createConverter(_annotationIntrospector.findSerializationConverter(_classInfo));
}
/**
* Method for determining whether null properties should be written
* out for a Bean of introspected type. This is based on global
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * feature (lowest priority, passed as argument)
* and per-class annotation (highest priority).
*/
@Override
public JsonInclude.Include findSerializationInclusion(JsonInclude.Include defValue) {
if (_annotationIntrospector == null) {
return defValue;
}
return _annotationIntrospector.findSerializationInclusion(_classInfo, defValue);
}
@Override
public JsonInclude.Include findSerializationInclusionForContent(JsonInclude.Include defValue) {
if (_annotationIntrospector == null) {
return defValue;
}
return _annotationIntrospector.findSerializationInclusionForContent(_classInfo, defValue);
}
/**
* Method used to locate the method of introspected class that
* implements {@link com.fasterxml.jackson.annotation.JsonAnyGetter}.
* If no such method exists null is returned.
* If more than one are found, an exception is thrown.
*/
@Override
public AnnotatedMember findAnyGetter() throws IllegalArgumentException
{
if (_anyGetter != null) {
/* For now let's require a Map; in future can add support for other
* types like perhaps Iterable<Map.Entry>?
*/
Class<?> type = _anyGetter.getRawType();
if (!Map.class.isAssignableFrom(type)) {
throw new IllegalArgumentException("Invalid 'any-getter' annotation on method "+_anyGetter.getName()+"(): return type is not instance of java.util.Map");
}
}
return _anyGetter;
}
@Override
public Map<String,AnnotatedMember> findBackReferenceProperties()
{
HashMap<String,AnnotatedMember> result = null;
// boolean hasIgnored = (_ignoredPropertyNames != null);
for (BeanPropertyDefinition property : _properties) {
/* 23-Sep-2014, tatu: As per [Databind#426], we _should_ try to avoid
* calling accessor, as it triggers exception from seeming conflict.
* But the problem is that _ignoredPropertyNames here only contains
* ones ignored on per-property annotations, but NOT class annotations...
* so commented out part does not work, alas
*/
/*
if (hasIgnored && _ignoredPropertyNames.contains(property.getName())) {
continue;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Class<?> expArgType : expArgTypes) {
// And one that matches what we would pass in
if (actualArgType.isAssignableFrom(expArgType)) {
return am.getAnnotated();
}
}
}
}
return null;
}
protected boolean isFactoryMethod(AnnotatedMethod am)
{
/* First: return type must be compatible with the introspected class
* (i.e. allowed to be sub-class, although usually is the same
* class)
*/
Class<?> rt = am.getRawReturnType();
if (!getBeanClass().isAssignableFrom(rt)) {
return false;
}
/* Also: must be a recognized factory method, meaning:
* (a) marked with @JsonCreator annotation, or
* (b) "valueOf" (at this point, need not be public)
*/
if (_annotationIntrospector.hasCreatorAnnotation(am)) {
return true;
}
final String name = am.getName();
if ("valueOf".equals(name)) {
return true;
}
// [Issue#208] Also accept "fromString()", if takes String or CharSequence
if ("fromString".equals(name)) {
if (1 == am.getParameterCount()) {
Class<?> cls = am.getRawParameterType(0);
if (cls == String.class || CharSequence.class.isAssignableFrom(cls)) {
return true;
}
}
}
return false;
}
/**
* @deprecated Since 2.4, use <code>findCreatorParameterNames()</code> instead.
*/
@Deprecated
public List<String> findCreatorPropertyNames()
{
List<PropertyName> params = findCreatorParameterNames();
if (params.isEmpty()) {
return Collections.emptyList();
}
List<String> result = new ArrayList<String>(params.size());
for (PropertyName name : params) {
result.add(name.getSimpleName());
}
return result;
}
/**
* @deprecated Since 2.5, does not seem to be used at all.
*/
@Deprecated
public List<PropertyName> findCreatorParameterNames()
{
for (int i = 0; i < 2; ++i) {
List<? extends AnnotatedWithParams> l = (i == 0)
? getConstructors
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> logical property name as key, and
* matching field as value.
*/
public LinkedHashMap<String,AnnotatedField> _findPropertyFields(
Collection<String> ignoredProperties, boolean forSerialization)
{
LinkedHashMap<String,AnnotatedField> results = new LinkedHashMap<String,AnnotatedField>();
for (BeanPropertyDefinition property : _properties) {
AnnotatedField f = property.getField();
if (f != null) {
String name = property.getName();
if (ignoredProperties != null) {
if (ignoredProperties.contains(name)) {
continue;
}
}
results.put(name, f);
}
}
return results;
}
/*
/**********************************************************
/* Helper methods, other
/**********************************************************
*/
@SuppressWarnings("unchecked")
public Converter<Object,Object> _createConverter(Object converterDef)
{
if (converterDef == null) {
return null;
}
if (converterDef instanceof Converter<?,?>) {
return (Converter<Object,Object>) converterDef;
}
if (!(converterDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned Converter definition of type "
+converterDef.getClass().getName()+"; expected type Converter or Class<Converter> instead");
}
Class<?> converterClass = (Class<?>)converterDef;
// there are some known "no class" markers to consider too:
if (converterClass == Converter.None.class || ClassUtil.isBogusClass(converterClass)) {
return null;
}
if (!Converter.class.isAssignableFrom(converterClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "
+converterClass.getName()+"; expected Class<Converter>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
Converter<?,?> conv = (hi == null) ? null : hi.converterInstance(_config, _classInfo, converterClass);
if (conv == null) {
conv = (Converter<?,?>) ClassUtil.createInstance(converterClass,
_config.canOverrideAccessModifiers());
}
return (Converter<Object,Object>) conv;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> for example do not
* support this method.
*/
public abstract void set(Object instance, Object value) throws IOException;
/**
* Method called to assign given value to this property, on
* specified Object, and return whatever delegating accessor
* returned (if anything)
*<p>
* Note: this is an optional operation, not supported by all
* implementations, creator-backed properties for example do not
* support this method.
*/
public abstract Object setAndReturn(Object instance, Object value) throws IOException;
/**
* This method is needed by some specialized bean deserializers,
* and also called by some {@link #deserializeAndSet} implementations.
*<p>
* Pre-condition is that passed parser must point to the first token
* that should be consumed to produce the value (the only value for
* scalars, multiple for Objects and Arrays).
*<p>
* Note that this method is final for performance reasons: to override
* functionality you must override other methods that call this method;
* this method should also not be called directly unless you really know
* what you are doing (and probably not even then).
*/
public final Object deserialize(JsonParser p, DeserializationContext ctxt) throws IOException
{
JsonToken t = p.getCurrentToken();
if (t == JsonToken.VALUE_NULL) {
return (_nullProvider == null) ? null : _nullProvider.nullValue(ctxt);
}
if (_valueTypeDeserializer != null) {
return _valueDeserializer.deserializeWithType(p, ctxt, _valueTypeDeserializer);
}
return _valueDeserializer.deserialize(p, ctxt);
}
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
/**
* Method that takes in exception of any type, and casts or wraps it
* to an IOException or its subclass.
*/
protected void _throwAsIOE(Exception e, Object value) throws IOException
{
if (e instanceof IllegalArgumentException) {
String actType = (value == null) ? "[NULL]" : value.getClass().getName();
StringBuilder msg = new StringBuilder("Problem deserializing property '").append(getName());
msg.append("' (expected type: ").append(getType());
msg.append("; actual type: ").append(actType).append(")");
String origMsg = e.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/**
* Helper class needed to be able to efficiently access class
* member functions ({@link Method}s and {@link Constructor}s)
* in {@link java.util.Map}s.
*/
public final class MemberKey
{
final static Class<?>[] NO_CLASSES = new Class<?>[0];
final String _name;
final Class<?>[] _argTypes;
public MemberKey(Method m)
{
this(m.getName(), m.getParameterTypes());
}
public MemberKey(Constructor<?> ctor)
{
this("", ctor.getParameterTypes());
}
public MemberKey(String name, Class<?>[] argTypes)
{
_name = name;
_argTypes = (argTypes == null) ? NO_CLASSES : argTypes;
}
@Override
public String toString() {
return _name + "(" + _argTypes.length+"-args)";
}
@Override
public int hashCode()
{
return _name.hashCode() + _argTypes.length;
}
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) {
return false;
}
MemberKey other = (MemberKey) o;
if (!_name.equals(other._name)) {
return false;
}
Class<?>[] otherArgs = other._argTypes;
int len = _argTypes.length;
if (otherArgs.length != len) {
return false;
}
for (int i = 0; i < len; ++i) {
Class<?> type1 = otherArgs[i];
Class<?> type2 = _argTypes[i];
if (type1 == type2) {
continue;
}
/* 23-Feb-2009, tatu: Are there any cases where we would have to
* consider some narrowing conversions or such? For now let's
* assume exact type match is enough
*/
/* 07-Apr-2009, tatu: Indeed there are (see [JACKSON-
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicReference;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
public class AtomicReferenceDeserializer
extends StdDeserializer<AtomicReference<?>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
/**
* Type of value that we reference
*/
protected final JavaType _referencedType;
protected final TypeDeserializer _valueTypeDeserializer;
protected final JsonDeserializer<?> _valueDeserializer;
/**
* @param referencedType Parameterization of this reference
*/
public AtomicReferenceDeserializer(JavaType referencedType) {
this(referencedType, null, null);
}
public AtomicReferenceDeserializer(JavaType referencedType, TypeDeserializer typeDeser, JsonDeserializer<?> deser)
{
super(AtomicReference.class);
_referencedType = referencedType;
_valueDeserializer = deser;
_valueTypeDeserializer = typeDeser;
}
public AtomicReferenceDeserializer withResolved(TypeDeserializer typeDeser, JsonDeserializer<?> valueDeser) {
return new AtomicReferenceDeserializer(_referencedType, typeDeser, valueDeser);
}
// Added in 2.3
@Override
public AtomicReference<?> getNullValue() {
return new AtomicReference<Object>();
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _valueDeserializer;
TypeDeserializer typeDeser = _valueTypeDeserializer;
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(_referencedType, property);
}
if (typeDeser != null) {
typeDeser = typeDeser.forProperty(property);
}
if (deser == _valueDeserializer && typeDeser == _valueTypeDeserializer) {
return this;
}
return withResolved(typeDeser, deser);
}
@Override
public AtomicReference<?> deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
/* 06-Nov-2013, tatu: Looks like the
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util;
import java.lang.reflect.*;
import java.util.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
public final class ClassUtil
{
/*
/**********************************************************
/* Methods that deal with inheritance
/**********************************************************
*/
/**
* Method that will find all sub-classes and implemented interfaces
* of a given class or interface. Classes are listed in order of
* precedence, starting with the immediate super-class, followed by
* interfaces class directly declares to implemented, and then recursively
* followed by parent of super-class and so forth.
* Note that <code>Object.class</code> is not included in the list
* regardless of whether <code>endBefore</code> argument is defined or not.
*
* @param endBefore Super-type to NOT include in results, if any; when
* encountered, will be ignored (and no super types are checked).
*/
public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore) {
return findSuperTypes(cls, endBefore, new ArrayList<Class<?>>(8));
}
public static List<Class<?>> findSuperTypes(Class<?> cls, Class<?> endBefore, List<Class<?>> result) {
_addSuperTypes(cls, endBefore, result, false);
return result;
}
private static void _addSuperTypes(Class<?> cls, Class<?> endBefore, Collection<Class<?>> result, boolean addClassItself) {
if (cls == endBefore || cls == null || cls == Object.class) { return; }
if (addClassItself) {
if (result.contains(cls)) { // already added, no need to check supers
return;
}
result.add(cls);
}
for (Class<?> intCls : cls.getInterfaces()) {
_addSuperTypes(intCls, endBefore, result, true);
}
_addSuperTypes(cls.getSuperclass(), endBefore, result, true);
}
/*
/**********************************************************
/* Class type detection methods
/**********************************************************
*/
/**
* @return Null if class might be a bean; type String (that identifies
* why it's not a bean) if not
*/
public static String
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>property) based serialization.
*/
public static boolean isProxyType(Class<?> type)
{
// As per [Issue#57], should NOT disqualify JDK proxy:
/*
// Then: well-known proxy (etc) classes
if (Proxy.isProxyClass(type)) {
return true;
}
*/
String name = type.getName();
// Hibernate uses proxies heavily as well:
if (name.startsWith("net.sf.cglib.proxy.")
|| name.startsWith("org.hibernate.proxy.")) {
return true;
}
// Not one of known proxies, nope:
return false;
}
/**
* Helper method that checks if given class is a concrete one;
* that is, not an interface or abstract class.
*/
public static boolean isConcrete(Class<?> type)
{
int mod = type.getModifiers();
return (mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0;
}
public static boolean isConcrete(Member member)
{
int mod = member.getModifiers();
return (mod & (Modifier.INTERFACE | Modifier.ABSTRACT)) == 0;
}
public static boolean isCollectionMapOrArray(Class<?> type)
{
if (type.isArray()) return true;
if (Collection.class.isAssignableFrom(type)) return true;
if (Map.class.isAssignableFrom(type)) return true;
return false;
}
/*
/**********************************************************
/* Type name handling methods
/**********************************************************
*/
/**
* Helper method used to construct appropriate description
* when passed either type (Class) or an instance; in latter
* case, class of instance is to be used.
*/
public static String getClassDescription(Object classOrInstance)
{
if (classOrInstance == null) {
return "unknown";
}
Class<?> cls = (classOrInstance instanceof Class<?>) ?
(Class<?>) classOrInstance : classOrInstance.getClass();
return cls.getName();
}
/*
/**********************************************************
/* Class loading
/**********************************************************
*/
public static Class<?> findClass(String className) throws ClassNotFoundException
{
// [JACKSON-597]: support primitive types (and void)
if (className.indexOf('.') < 0) {
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> (cls == Float.TYPE) {
return Float.valueOf(0.0f);
}
if (cls == Byte.TYPE) {
return Byte.valueOf((byte) 0);
}
if (cls == Short.TYPE) {
return Short.valueOf((short) 0);
}
if (cls == Character.TYPE) {
return '\0';
}
throw new IllegalArgumentException("Class "+cls.getName()+" is not a primitive type");
}
/**
* Helper method for finding wrapper type for given primitive type (why isn't
* there one in JDK?)
*/
public static Class<?> wrapperType(Class<?> primitiveType)
{
if (primitiveType == Integer.TYPE) {
return Integer.class;
}
if (primitiveType == Long.TYPE) {
return Long.class;
}
if (primitiveType == Boolean.TYPE) {
return Boolean.class;
}
if (primitiveType == Double.TYPE) {
return Double.class;
}
if (primitiveType == Float.TYPE) {
return Float.class;
}
if (primitiveType == Byte.TYPE) {
return Byte.class;
}
if (primitiveType == Short.TYPE) {
return Short.class;
}
if (primitiveType == Character.TYPE) {
return Character.class;
}
throw new IllegalArgumentException("Class "+primitiveType.getName()+" is not a primitive type");
}
/*
/**********************************************************
/* Access checking/handling methods
/**********************************************************
*/
/**
* Method called to check if we can use the passed method or constructor
* (wrt access restriction -- public methods can be called, others
* usually not); and if not, if there is a work-around for
* the problem.
*/
public static void checkAndFixAccess(Member member)
{
// We know all members are also accessible objects...
AccessibleObject ao = (AccessibleObject) member;
/* 14-Jan-2009, tatu: It seems safe and potentially beneficial to
* always to make it accessible (latter because it will force
* skipping checks we have no use for...), so let's always call it.
*/
//if (!ao.isAccessible()) {
try {
ao.setAccessible(true
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> Class<?> ec = en.getClass();
if (ec.getSuperclass() != Enum.class) {
ec = ec.getSuperclass();
}
return (Class<? extends Enum<?>>) ec;
}
/**
* Helper method that can be used to dynamically figure out formal
* enumeration type (class) for given class of an enumeration value.
* This is either class of enum instance (for "simple" enumerations),
* or its superclass (for enums with instance fields or methods)
*/
@SuppressWarnings("unchecked")
public static Class<? extends Enum<?>> findEnumType(Class<?> cls)
{
// enums with "body" are sub-classes of the formal type
if (cls.getSuperclass() != Enum.class) {
cls = cls.getSuperclass();
}
return (Class<? extends Enum<?>>) cls;
}
/*
/**********************************************************
/* Jackson-specific stuff
/**********************************************************
*/
/**
* Method that can be called to determine if given Object is the default
* implementation Jackson uses; as opposed to a custom serializer installed by
* a module or calling application. Determination is done using
* {@link JacksonStdImpl} annotation on handler (serializer, deserializer etc)
* class.
*/
public static boolean isJacksonStdImpl(Object impl) {
return (impl != null) && isJacksonStdImpl(impl.getClass());
}
public static boolean isJacksonStdImpl(Class<?> implClass) {
return (implClass.getAnnotation(JacksonStdImpl.class) != null);
}
public static boolean isBogusClass(Class<?> cls) {
return (cls == Void.class || cls == Void.TYPE
|| cls == com.fasterxml.jackson.databind.annotation.NoClass.class);
}
public static boolean isNonStaticInnerClass(Class<?> cls) {
return (cls.getEnclosingClass() != null)
&& !Modifier.isStatic(cls.getModifiers());
}
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* Inner class used to contain gory details of how we can determine
* details of instances of common JDK types like {@link EnumMap}s.
*/
private static class EnumTypeLocator
{
final
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> static EnumTypeLocator instance = new EnumTypeLocator();
private final Field enumSetTypeField;
private final Field enumMapTypeField;
private EnumTypeLocator() {
/* JDK uses following fields to store information about actual Enumeration
* type for EnumSets, EnumMaps...
*/
enumSetTypeField = locateField(EnumSet.class, "elementType", Class.class);
enumMapTypeField = locateField(EnumMap.class, "elementType", Class.class);
}
@SuppressWarnings("unchecked")
public Class<? extends Enum<?>> enumTypeFor(EnumSet<?> set)
{
if (enumSetTypeField != null) {
return (Class<? extends Enum<?>>) get(set, enumSetTypeField);
}
throw new IllegalStateException("Can not figure out type for EnumSet (odd JDK platform?)");
}
@SuppressWarnings("unchecked")
public Class<? extends Enum<?>> enumTypeFor(EnumMap<?,?> set)
{
if (enumMapTypeField != null) {
return (Class<? extends Enum<?>>) get(set, enumMapTypeField);
}
throw new IllegalStateException("Can not figure out type for EnumMap (odd JDK platform?)");
}
private Object get(Object bean, Field field)
{
try {
return field.get(bean);
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}
private static Field locateField(Class<?> fromClass, String expectedName, Class<?> type)
{
Field found = null;
// First: let's see if we can find exact match:
Field[] fields = fromClass.getDeclaredFields();
for (Field f : fields) {
if (expectedName.equals(f.getName()) && f.getType() == type) {
found = f;
break;
}
}
// And if not, if there is just one field with the type, that field
if (found == null) {
for (Field f : fields) {
if (f.getType() == type) {
// If more than one, can't choose
if (found != null) return null;
found
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>+SAMPLE_SPEC_VALUE_TN_ID4+"]\n"
+" }"
+"}"
;
/*
/**********************************************************
/* Helper classes (beans)
/**********************************************************
*/
/**
* Sample class from Jackson tutorial ("JacksonInFiveMinutes")
*/
protected static class FiveMinuteUser {
public enum Gender { MALE, FEMALE };
public static class Name
{
private String _first, _last;
public Name() { }
public Name(String f, String l) {
_first = f;
_last = l;
}
public String getFirst() { return _first; }
public String getLast() { return _last; }
public void setFirst(String s) { _first = s; }
public void setLast(String s) { _last = s; }
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
Name other = (Name) o;
return _first.equals(other._first) && _last.equals(other._last);
}
}
private Gender _gender;
private Name _name;
private boolean _isVerified;
private byte[] _userImage;
public FiveMinuteUser() { }
public FiveMinuteUser(String first, String last, boolean verified, Gender g, byte[] data)
{
_name = new Name(first, last);
_isVerified = verified;
_gender = g;
_userImage = data;
}
public Name getName() { return _name; }
public boolean isVerified() { return _isVerified; }
public Gender getGender() { return _gender; }
public byte[] getUserImage() { return _userImage; }
public void setName(Name n) { _name = n; }
public void setVerified(boolean b) { _isVerified = b; }
public void setGender(Gender g) { _gender = g; }
public void setUserImage(byte[] b) { _userImage = b; }
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, String encoding)
throws IOException, JsonParseException
{
/* 23-Apr-2008, tatus: UTF-32 is not supported by JDK, have to
* use our own codec too (which is not optimal since there's
* a chance both encoder and decoder might have bugs, but ones
* that cancel each other out or such)
*/
byte[] data;
if (encoding.equalsIgnoreCase("UTF-32")) {
data = encodeInUTF32BE(input);
} else {
data = input.getBytes(encoding);
}
InputStream is = new ByteArrayInputStream(data);
return f.createParser(is);
}
/*
/**********************************************************
/* Additional assertion methods
/**********************************************************
*/
protected void assertToken(JsonToken expToken, JsonToken actToken)
{
if (actToken != expToken) {
fail("Expected token "+expToken+", current token "+actToken);
}
}
protected void assertToken(JsonToken expToken, JsonParser jp)
{
assertToken(expToken, jp.getCurrentToken());
}
protected void assertType(Object ob, Class<?> expType)
{
if (ob == null) {
fail("Expected an object of type "+expType.getName()+", got null");
}
Class<?> cls = ob.getClass();
if (!expType.isAssignableFrom(cls)) {
fail("Expected type "+expType.getName()+", got "+cls.getName());
}
}
protected void assertValidLocation(JsonLocation location) {
assertNotNull("Should have non-null location", location);
assertTrue("Should have positive line number", location.getLineNr() > 0);
}
protected void verifyException(Throwable e, String... matches)
{
String msg = e.getMessage();
String lmsg = (msg == null) ? "" : msg.toLowerCase();
for (String match : matches) {
String lmatch = match.toLowerCase();
if (lmsg.indexOf(lmatch) >= 0) {
return;
}
}
fail("Expected an exception with one of substrings ("+Arrays.asList(matches)+"): got one with message \""+msg+"\"");
}
/**
* Method that gets textual contents of the current token using
* available methods, and ensures results
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.util.Map;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.ser.SerializerCache.TypeKey;
/**
* Specialized read-only map used for storing and accessing serializers by type.
* Used for per-{@link com.fasterxml.jackson.databind.ObjectMapper} sharing
* of resolved serializers; in addition, a per-call non-shared read/write
* map may be needed, which will (after call) get merged to create a new
* shared map of this type.
*/
public class JsonSerializerMap
{
private final Bucket[] _buckets;
private final int _size;
public JsonSerializerMap(Map<TypeKey,JsonSerializer<Object>> serializers)
{
int size = findSize(serializers.size());
_size = size;
int hashMask = (size-1);
Bucket[] buckets = new Bucket[size];
for (Map.Entry<TypeKey,JsonSerializer<Object>> entry : serializers.entrySet()) {
TypeKey key = entry.getKey();
int index = key.hashCode() & hashMask;
buckets[index] = new Bucket(buckets[index], key, entry.getValue());
}
_buckets = buckets;
}
private final static int findSize(int size)
{
// For small enough results (64 or less), we'll require <= 50% fill rate; otherwise 80%
int needed = (size <= 64) ? (size + size) : (size + (size >> 2));
int result = 8;
while (result < needed) {
result += result;
}
return result;
}
/*
/**********************************************************
/* Public API
/**********************************************************
*/
public int size() { return _size; }
public JsonSerializer<Object> find(TypeKey key)
{
int index = key.hashCode() & (_buckets.length-1);
Bucket bucket = _buckets[index];
/* Ok let's actually try unrolling loop slightly as this shows up in profiler;
* and also because in vast majority of cases first entry is either null
* or matches.
*/
if (bucket == null) {
return null;
}
if (key.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>link JsonGenerator}
* constructed for serializing values.
*
* @since 2.5
*/
protected final GeneratorSettings _generatorSettings;
/**
* We may pre-fetch serializer if {@link #_rootType}
* is known, and if so, reuse it afterwards.
* This allows avoiding further serializer lookups and increases
* performance a bit on cases where readers are reused.
*
* @since 2.5
*/
protected final Prefetch _prefetch;
/*
/**********************************************************
/* Life-cycle, constructors
/**********************************************************
*/
/**
* Constructor used by {@link ObjectMapper} for initial instantiation
*/
protected ObjectWriter(ObjectMapper mapper, SerializationConfig config,
JavaType rootType, PrettyPrinter pp)
{
_config = config;
_serializerProvider = mapper._serializerProvider;
_serializerFactory = mapper._serializerFactory;
_generatorFactory = mapper._jsonFactory;
_generatorSettings = (pp == null) ? GeneratorSettings.empty
: new GeneratorSettings(pp, null, null, null);
// 29-Apr-2014, tatu: There is no "untyped serializer", so:
if (rootType == null || rootType.hasRawClass(Object.class)) {
_prefetch = Prefetch.empty;
} else {
rootType = rootType.withStaticTyping();
_prefetch = _prefetchRootSerializer(config, rootType);
}
}
/**
* Alternative constructor for initial instantiation by {@link ObjectMapper}
*/
protected ObjectWriter(ObjectMapper mapper, SerializationConfig config)
{
_config = config;
_serializerProvider = mapper._serializerProvider;
_serializerFactory = mapper._serializerFactory;
_generatorFactory = mapper._jsonFactory;
_prefetch = Prefetch.empty;
_generatorSettings = GeneratorSettings.empty;
}
/**
* Alternative constructor for initial instantiation by {@link ObjectMapper}
*/
protected ObjectWriter(ObjectMapper mapper, SerializationConfig config,
FormatSchema s)
{
_config = config;
_serializerProvider = mapper._serializerProvider;
_serializerFactory = mapper._serializerFactory;
_generatorFactory = mapper._jsonFactory;
_prefetch = Prefetch.empty;
_generatorSettings = (s == null) ? GeneratorSettings.empty
: new GeneratorSettings
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> /**
* @deprecated Since 2.5 use {@link #with(FormatSchema)} instead
*/
@Deprecated
public ObjectWriter withSchema(FormatSchema schema) {
return with(schema);
}
/**
* Method that will construct a new instance that uses specific type
* as the root type for serialization, instead of runtime dynamic
* type of the root object itself.
*<p>
* Note that method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*
* @since 2.5
*/
public ObjectWriter forType(JavaType rootType)
{
Prefetch pf;
if (rootType == null || rootType.hasRawClass(Object.class)) {
pf = Prefetch.empty;
} else {
// 15-Mar-2013, tatu: Important! Indicate that static typing is needed:
rootType = rootType.withStaticTyping();
pf = _prefetchRootSerializer(_config, rootType);
}
return (pf == _prefetch) ? this : _new(_generatorSettings, pf);
}
/**
* Method that will construct a new instance that uses specific type
* as the root type for serialization, instead of runtime dynamic
* type of the root object itself.
*
* @since 2.5
*/
public ObjectWriter forType(Class<?> rootType) {
if (rootType == Object.class) {
return forType((JavaType) null);
}
return forType(_config.constructType(rootType));
}
public ObjectWriter forType(TypeReference<?> rootType) {
return forType(_config.getTypeFactory().constructType(rootType.getType()));
}
/**
* @deprecated since 2.5 Use {@link #forType(JavaType)} instead
*/
@Deprecated // since 2.5
public ObjectWriter withType(JavaType rootType) {
return forType(rootType);
}
/**
* @deprecated since 2.5 Use {@link #forType(Class)} instead
*/
@Deprecated // since 2.5
public ObjectWriter withType(Class<?> rootType) {
return forType(rootType);
}
/**
* @deprecated since 2.5 Use {@link #
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>) {
return _serializerProvider(_config).hasSerializerFor(type, cause);
}
/*
/**********************************************************
/* Overridable helper methods
/**********************************************************
*/
/**
* Overridable helper method used for constructing
* {@link SerializerProvider} to use for serialization.
*/
protected DefaultSerializerProvider _serializerProvider(SerializationConfig config) {
return _serializerProvider.createInstance(config, _serializerFactory);
}
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
/**
* @since 2.2
*/
protected void _verifySchemaType(FormatSchema schema)
{
if (schema != null) {
if (!_generatorFactory.canUseSchema(schema)) {
throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName()
+" for format "+_generatorFactory.getFormatName());
}
}
}
/**
* Method called to configure the generator as necessary and then
* call write functionality
*/
protected final void _configAndWriteValue(JsonGenerator gen, Object value) throws IOException
{
_configureGenerator(gen);
// [JACKSON-282]: consider Closeable
if (_config.isEnabled(SerializationFeature.CLOSE_CLOSEABLE) && (value instanceof Closeable)) {
_writeCloseable(gen, value, _config);
return;
}
boolean closed = false;
try {
if (_prefetch.valueSerializer != null) {
_serializerProvider(_config).serializeValue(gen, value, _prefetch.rootType,
_prefetch.valueSerializer);
} else if (_prefetch.typeSerializer != null) {
_serializerProvider(_config).serializePolymorphic(gen, value, _prefetch.typeSerializer);
} else {
_serializerProvider(_config).serializeValue(gen, value);
}
closed = true;
gen.close();
} finally {
/* won't try to close twice; also, must catch exception (so it
* will not mask exception that is pending)
*/
if (!closed) {
/* 04-Mar-2014, tatu: But! Let's try to prevent auto-closing of
* structures, which typically causes more damage.
*/
gen.disable(JsonGenerator.Feature.AUTO_CLOSE_JSON_CONTENT);
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> unwrapped values (via @JsonUnwrapped)
SettableBeanProperty u = _resolveUnwrappedProperty(ctxt, prop);
if (u != null) {
prop = u;
if (unwrapped == null) {
unwrapped = new UnwrappedPropertyHandler();
}
unwrapped.addProperty(prop);
/* 12-Dec-2014, tatu: As per [databind#647], we will have problems if
* the original property is left in place. So let's remove it now.
*/
_beanProperties.remove(prop);
continue;
}
// [JACKSON-594]: non-static inner classes too:
prop = _resolveInnerClassValuedProperty(ctxt, prop);
if (prop != origProp) {
_beanProperties.replace(prop);
}
/* one more thing: if this property uses "external property" type inclusion
* (see [JACKSON-453]), it needs different handling altogether
*/
if (prop.hasValueTypeDeserializer()) {
TypeDeserializer typeDeser = prop.getValueTypeDeserializer();
if (typeDeser.getTypeInclusion() == JsonTypeInfo.As.EXTERNAL_PROPERTY) {
if (extTypes == null) {
extTypes = new ExternalTypeHandler.Builder();
}
extTypes.addExternal(prop, typeDeser);
// In fact, remove from list of known properties to simplify later handling
_beanProperties.remove(prop);
continue;
}
}
}
// "any setter" may also need to be resolved now
if (_anySetter != null && !_anySetter.hasValueDeserializer()) {
_anySetter = _anySetter.withValueDeserializer(findDeserializer(ctxt,
_anySetter.getType(), _anySetter.getProperty()));
}
// as well as delegate-based constructor:
if (_valueInstantiator.canCreateUsingDelegate()) {
JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig());
if (delegateType == null) {
throw new IllegalArgumentException("Invalid delegate-creator definition for "+_beanType
+": value instantiator ("+_valueInstantiator.getClass().getName()
+") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
}
AnnotatedWithParams
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> is done in resolve(), we only get
* access to referring property's annotations here; and this is needed
* to support per-property ObjectIds.
* We will also consider Shape transformations (read from Array) at this
* point, since it may come from either Class definition or property.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
ObjectIdReader oir = _objectIdReader;
// First: may have an override for Object Id:
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
final AnnotatedMember accessor = (property == null || intr == null)
? null : property.getMember();
if (accessor != null && intr != null) {
ObjectIdInfo objectIdInfo = intr.findObjectIdInfo(accessor);
if (objectIdInfo != null) { // some code duplication here as well (from BeanDeserializerFactory)
// 2.1: allow modifications by "id ref" annotations as well:
objectIdInfo = intr.findObjectReferenceInfo(accessor, objectIdInfo);
Class<?> implClass = objectIdInfo.getGeneratorType();
// Property-based generator is trickier
JavaType idType;
SettableBeanProperty idProp;
ObjectIdGenerator<?> idGen;
ObjectIdResolver resolver = ctxt.objectIdResolverInstance(accessor, objectIdInfo);
if (implClass == ObjectIdGenerators.PropertyGenerator.class) {
PropertyName propName = objectIdInfo.getPropertyName();
idProp = findProperty(propName);
if (idProp == null) {
throw new IllegalArgumentException("Invalid Object Id definition for "
+handledType().getName()+": can not find property with name '"+propName+"'");
}
idType = idProp.getType();
idGen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope());
} else { // other types need to be simpler
JavaType type = ctxt.constructType(implClass);
idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
idProp = null;
idGen = ctxt.objectIdGeneratorInstance(accessor, objectIdInfo);
}
JsonDeserializer<?> deser = ctxt.findRootValueDeserializer(idType);
oir = ObjectIdReader.construct(idType, objectIdInfo.getPropertyName(),
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Token();
if (t != null) {
// Most commonly, a scalar (int id, uuid String, ...)
if (t.isScalarValue()) {
return deserializeFromObjectId(p, ctxt);
}
// but, with 2.5+, a simple Object-wrapped value also legal:
if (t == JsonToken.START_OBJECT) {
t = p.nextToken();
}
if (t == JsonToken.FIELD_NAME && _objectIdReader.maySerializeAsObject()
&& _objectIdReader.isValidReferencePropertyName(p.getCurrentName(), p)) {
return deserializeFromObjectId(p, ctxt);
}
}
}
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromObject(p, ctxt);
}
/**
* Offlined method called to handle "native" Object Id that has been read
* and known to be associated with given deserialized POJO.
*
* @since 2.3
*/
protected Object _handleTypedObjectId(JsonParser jp, DeserializationContext ctxt,
Object pojo, Object rawId)
throws IOException
{
/* 07-Aug-2013, tatu: One more challenge: type of id may not be type
* of property we are expecting later on; specifically, numeric ids
* vs Strings.
*/
JsonDeserializer<Object> idDeser = _objectIdReader.getDeserializer();
final Object id;
// Ok, this is bit ridiculous; let's see if conversion is needed:
if (idDeser.handledType() == rawId.getClass()) {
// nope: already same type
id = rawId;
} else {
id = _convertObjectId(jp, ctxt, rawId, idDeser);
}
ReadableObjectId roid = ctxt.findObjectId(id, _objectIdReader.generator, _objectIdReader.resolver);
roid.bindItem(pojo);
// also: may need to set a property value as well
SettableBeanProperty idProp = _objectIdReader.idProperty;
if (idProp != null) {
return idProp.setAndReturn(pojo, id);
}
return pojo;
}
/**
* Helper method we need to do necessary conversion from whatever native object id
*
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> all properties are passed
* in buffer
*/
@SuppressWarnings("resource")
protected Object handlePolymorphic(JsonParser jp, DeserializationContext ctxt,
Object bean, TokenBuffer unknownTokens)
throws IOException, JsonProcessingException
{
// First things first: maybe there is a more specific deserializer available?
JsonDeserializer<Object> subDeser = _findSubclassDeserializer(ctxt, bean, unknownTokens);
if (subDeser != null) {
if (unknownTokens != null) {
// need to add END_OBJECT marker first
unknownTokens.writeEndObject();
JsonParser p2 = unknownTokens.asParser();
p2.nextToken(); // to get to first data field
bean = subDeser.deserialize(p2, ctxt, bean);
}
// Original parser may also have some leftovers
if (jp != null) {
bean = subDeser.deserialize(jp, ctxt, bean);
}
return bean;
}
// nope; need to use this deserializer. Unknowns we've seen so far?
if (unknownTokens != null) {
bean = handleUnknownProperties(ctxt, bean, unknownTokens);
}
// and/or things left to process via main parser?
if (jp != null) {
bean = deserialize(jp, ctxt, bean);
}
return bean;
}
/**
* Helper method called to (try to) locate deserializer for given sub-type of
* type that this deserializer handles.
*/
protected JsonDeserializer<Object> _findSubclassDeserializer(DeserializationContext ctxt,
Object bean, TokenBuffer unknownTokens)
throws IOException, JsonProcessingException
{
JsonDeserializer<Object> subDeser;
// First: maybe we have already created sub-type deserializer?
synchronized (this) {
subDeser = (_subDeserializers == null) ? null : _subDeserializers.get(new ClassKey(bean.getClass()));
}
if (subDeser != null) {
return subDeser;
}
// If not, maybe we can locate one. First, need provider
JavaType type = ctxt.constructType(bean.getClass());
/* 30-Jan-2012, tatu: Ideally we would be passing referring
* property; which in theory we could keep track of
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> via
* ResolvableDeserializer (if we absolutely must...).
* But for now, let's not bother.
*/
// subDeser = ctxt.findValueDeserializer(type, _property);
subDeser = ctxt.findRootValueDeserializer(type);
// Also, need to cache it
if (subDeser != null) {
synchronized (this) {
if (_subDeserializers == null) {
_subDeserializers = new HashMap<ClassKey,JsonDeserializer<Object>>();;
}
_subDeserializers.put(new ClassKey(bean.getClass()), subDeser);
}
}
return subDeser;
}
/*
/**********************************************************
/* Helper methods for error reporting
/**********************************************************
*/
/**
* Method that will modify caught exception (passed in as argument)
* as necessary to include reference information, and to ensure it
* is a subtype of {@link IOException}, or an unchecked exception.
*<p>
* Rules for wrapping and unwrapping are bit complicated; essentially:
*<ul>
* <li>Errors are to be passed as is (if uncovered via unwrapping)
* <li>"Plain" IOExceptions (ones that are not of type
* {@link JsonMappingException} are to be passed as is
*</ul>
*/
public void wrapAndThrow(Throwable t, Object bean, String fieldName, DeserializationContext ctxt)
throws IOException
{
// [JACKSON-55] Need to add reference information
throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, fieldName);
}
@Deprecated // since 2.4, not used by core Jackson; only relevant for arrays/Collections
public void wrapAndThrow(Throwable t, Object bean, int index, DeserializationContext ctxt) throws IOException {
// [JACKSON-55] Need to add reference information
throw JsonMappingException.wrapWithPath(throwOrReturnThrowable(t, ctxt), bean, index);
}
private Throwable throwOrReturnThrowable(Throwable t, DeserializationContext ctxt)
throws IOException
{
/* 05-Mar-2009, tatu: But one nasty edge is when we get
* StackOverflow: usually due to infinite loop. But that
* often gets
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * for structured types, or serializers for root values)
* to handle details of resolving
* {@link ContextualDeserializer} with given property context.
* Given that these serializers are not directly related to given property
* (or, in case of root value property, to any property), annotations
* accessible may or may not be relevant.
*
* @param property Property for which serializer is used, if any; null
* when deserializing root values
*
* @since 2.3
*/
public JsonSerializer<?> handleSecondaryContextualization(JsonSerializer<?> ser,
BeanProperty property)
throws JsonMappingException
{
if (ser != null) {
if (ser instanceof ContextualSerializer) {
ser = ((ContextualSerializer) ser).createContextual(this, property);
}
}
return ser;
}
/*
/********************************************************
/* Convenience methods for serializing using default methods
/********************************************************
*/
/**
* Convenience method that will serialize given value (which can be
* null) using standard serializer locating functionality. It can
* be called for all values including field and Map values, but usually
* field values are best handled calling
* {@link #defaultSerializeField} instead.
*/
public final void defaultSerializeValue(Object value, JsonGenerator jgen) throws IOException
{
if (value == null) {
if (_stdNullValueSerializer) { // minor perf optimization
jgen.writeNull();
} else {
_nullValueSerializer.serialize(null, jgen, this);
}
} else {
Class<?> cls = value.getClass();
findTypedValueSerializer(cls, true, null).serialize(value, jgen, this);
}
}
/**
* Convenience method that will serialize given field with specified
* value. Value may be null. Serializer is done using the usual
* null) using standard serializer locating functionality.
*/
public final void defaultSerializeField(String fieldName, Object value, JsonGenerator jgen)
throws IOException
{
jgen.writeFieldName(fieldName);
if (value == null) {
/* Note: can't easily check for suppression at this point
* any more; caller must check it.
*/
if (_stdNullValueSerializer) { // minor perf optimization
jgen.writeNull();
} else {
_nullValueSerializer.serialize(
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>null, jgen, this);
}
} else {
Class<?> cls = value.getClass();
findTypedValueSerializer(cls, true, null).serialize(value, jgen, this);
}
}
/**
* Method that will handle serialization of Date(-like) values, using
* {@link SerializationConfig} settings to determine expected serialization
* behavior.
* Note: date here means "full" date, that is, date AND time, as per
* Java convention (and not date-only values like in SQL)
*/
public final void defaultSerializeDateValue(long timestamp, JsonGenerator jgen)
throws IOException
{
// [JACKSON-87]: Support both numeric timestamps and textual
if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) {
jgen.writeNumber(timestamp);
} else {
jgen.writeString(_dateFormat().format(new Date(timestamp)));
}
}
/**
* Method that will handle serialization of Date(-like) values, using
* {@link SerializationConfig} settings to determine expected serialization
* behavior.
* Note: date here means "full" date, that is, date AND time, as per
* Java convention (and not date-only values like in SQL)
*/
public final void defaultSerializeDateValue(Date date, JsonGenerator jgen)
throws IOException
{
// [JACKSON-87]: Support both numeric timestamps and textual
if (isEnabled(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)) {
jgen.writeNumber(date.getTime());
} else {
jgen.writeString(_dateFormat().format(date));
}
}
/**
* Method that will handle serialization of Dates used as {@link java.util.Map} keys,
* based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
* value (and if using textual representation, configured date format)
*/
public void defaultSerializeDateKey(long timestamp, JsonGenerator jgen)
throws IOException
{
if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
jgen.writeFieldName(String.valueOf(timestamp));
} else {
jgen.writeFieldName(_dateFormat().format(new Date(timestamp)));
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> }
/**
* Method that will handle serialization of Dates used as {@link java.util.Map} keys,
* based on {@link SerializationFeature#WRITE_DATE_KEYS_AS_TIMESTAMPS}
* value (and if using textual representation, configured date format)
*/
public void defaultSerializeDateKey(Date date, JsonGenerator jgen) throws IOException
{
if (isEnabled(SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS)) {
jgen.writeFieldName(String.valueOf(date.getTime()));
} else {
jgen.writeFieldName(_dateFormat().format(date));
}
}
public final void defaultSerializeNull(JsonGenerator jgen) throws IOException
{
if (_stdNullValueSerializer) { // minor perf optimization
jgen.writeNull();
} else {
_nullValueSerializer.serialize(null, jgen, this);
}
}
/*
/********************************************************
/* Error reporting
/********************************************************
*/
/**
* @since 2.6
*/
public JsonMappingException mappingException(String message, Object... args) {
if (args != null && args.length > 0) {
message = String.format(message, args);
}
return new JsonMappingException(message);
}
/*
/********************************************************
/* Helper methods
/********************************************************
*/
protected void _reportIncompatibleRootType(Object value, JavaType rootType)
throws IOException, JsonProcessingException
{
/* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types,
* primitives
*/
if (rootType.isPrimitive()) {
Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass());
// If it's just difference between wrapper, primitive, let it slide
if (wrapperType.isAssignableFrom(value.getClass())) {
return;
}
}
throw new JsonMappingException("Incompatible types: declared root type ("+rootType+") vs "
+value.getClass().getName());
}
/**
* Method that will try to find a serializer, either from cache
* or by constructing one; but will not return an "unknown" serializer
* if this can not be done but rather returns null.
*
* @return Serializer if one
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.text.DateFormat;
import java.util.Calendar;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
/**
* Standard serializer for {@link java.util.Calendar}.
* As with other time/date types, is configurable to produce timestamps
* (standard Java 64-bit timestamp) or textual formats (usually ISO-8601).
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class CalendarSerializer
extends DateTimeSerializerBase<Calendar>
{
public static final CalendarSerializer instance = new CalendarSerializer();
public CalendarSerializer() { this(null, null); }
public CalendarSerializer(Boolean useTimestamp, DateFormat customFormat) {
super(Calendar.class, useTimestamp, customFormat);
}
@Override
public CalendarSerializer withFormat(Boolean timestamp, DateFormat customFormat) {
return new CalendarSerializer(timestamp, customFormat);
}
@Override
protected long _timestamp(Calendar value) {
return (value == null) ? 0L : value.getTimeInMillis();
}
@Override
public void serialize(Calendar value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
if (_asTimestamp(provider)) {
jgen.writeNumber(_timestamp(value));
} else if (_customFormat != null) {
// 21-Feb-2011, tatu: not optimal, but better than alternatives:
synchronized (_customFormat) {
// _customformat cannot parse Calendar, so Date should be passed
jgen.writeString(_customFormat.format(value.getTime()));
}
} else {
provider.defaultSerializeDateValue(value.getTime(), jgen);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import com.fasterxml.jackson.databind.JavaType;
/**
* Type that represents Java Collection types (Lists, Sets).
*/
public final class CollectionType
extends CollectionLikeType
{
private static final long serialVersionUID = -7834910259750909424L;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
private CollectionType(Class<?> collT, JavaType elemT,
Object valueHandler, Object typeHandler, boolean asStatic)
{
super(collT, elemT, valueHandler, typeHandler, asStatic);
}
@Override
protected JavaType _narrow(Class<?> subclass) {
return new CollectionType(subclass, _elementType, null, null, _asStatic);
}
@Override
public JavaType narrowContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _elementType.getRawClass()) {
return this;
}
return new CollectionType(_class, _elementType.narrowBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType widenContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _elementType.getRawClass()) {
return this;
}
return new CollectionType(_class, _elementType.widenBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
public static CollectionType construct(Class<?> rawType, JavaType elemT)
{
// nominally component types will be just Object.class
return new CollectionType(rawType, elemT, null, null, false);
}
// Since 1.7:
@Override
public CollectionType withTypeHandler(Object h) {
return new CollectionType(_class, _elementType, _valueHandler, h, _asStatic);
}
// Since 1.7:
@Override
public CollectionType withContentTypeHandler(Object h)
{
return new CollectionType(_class, _elementType.withTypeHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionType withValueHandler
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(Object h) {
return new CollectionType(_class, _elementType, h, _typeHandler, _asStatic);
}
@Override
public CollectionType withContentValueHandler(Object h) {
return new CollectionType(_class, _elementType.withValueHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionType withStaticTyping() {
if (_asStatic) {
return this;
}
return new CollectionType(_class, _elementType.withStaticTyping(),
_valueHandler, _typeHandler, true);
}
/*
/**********************************************************
/* Overridden accessors
/**********************************************************
*/
@Override
public Class<?> getParameterSource() {
return java.util.Collection.class;
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public String toString()
{
return "[collection type; class "+_class.getName()+", contains "+_elementType+"]";
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Annotation used for configuring serialization aspects, by attaching
* to "getter" methods or fields, or to value classes.
* When annotating value classes, configuration is used for instances
* of the value class but can be overridden by more specific annotations
* (ones that attach to methods or fields).
*<p>
* An example annotation would be:
*<pre>
* @JsonSerialize(using=MySerializer.class,
* as=MySubClass.class,
* typing=JsonSerialize.Typing.STATIC
* )
*</pre>
* (which would be redundant, since some properties block others:
* specifically, 'using' has precedence over 'as', which has precedence
* over 'typing' setting)
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@com.fasterxml.jackson.annotation.JacksonAnnotation
public @interface JsonSerialize
{
// // // Annotations for explicitly specifying deserializer
/**
* Serializer class to use for
* serializing associated value. Depending on what is annotated,
* value is either an instance of annotated class (used globablly
* anywhere where class serializer is needed); or only used for
* serializing property access via a getter method.
*/
public Class<? extends JsonSerializer<?>> using() default JsonSerializer.None.class;
/**
* Serializer class to use for serializing contents (elements
* of a Collection/array, values of Maps) of annotated property.
* Can only be used on properties (methods, fields, constructors),
* and not value classes themselves (as they are typically generic)
*/
public Class<? extends JsonSerializer<?>> contentUsing()
default JsonSerializer.None.class;
/**
* Serializer class to use for serializing Map keys
* of annotated property.
* Can only be used on properties (methods, fields, constructors),
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
* and not value classes themselves.
*/
public Class<? extends JsonSerializer<?>> keyUsing()
default JsonSerializer.None.class;
/**
* Serializer class to use for serializing nulls for properties that
* are annotated, instead of the
* default null serializer.
* Note that using this property when annotation types (classes) has
* no effect currently (it is possible this could be improved in future).
*
* @since 2.3
*/
public Class<? extends JsonSerializer<?>> nullsUsing()
default JsonSerializer.None.class;
// // // Annotations for type handling, explicit declaration
// // // (type used for choosing deserializer, if not explicitly
// // // specified)
/**
* Supertype (of declared type, which itself is supertype of runtime type)
* to use as type when locating serializer to use.
*<p>
* Bogus type {@link Void} can be used to indicate that declared
* type is used as is (i.e. this annotation property has no setting);
* this since annotation properties are not allowed to have null value.
*<p>
* Note: if {@link #using} is also used it has precedence
* (since it directly specifies
* serializer, whereas this would only be used to locate the
* serializer)
* and value of this annotation property is ignored.
*/
public Class<?> as() default Void.class;
/**
* Concrete type to serialize keys of {@link java.util.Map} as,
* instead of type otherwise declared.
* Must be a supertype of declared type; otherwise an exception may be
* thrown by serializer.
*/
public Class<?> keyAs() default Void.class;
/**
* Concrete type to serialize content value (elements
* of a Collection/array, values of Maps) as,
* instead of type otherwise declared.
* Must be a supertype of declared type; otherwise an exception may be
* thrown by serializer.
*/
public Class<?> contentAs() default Void.class;
/**
* Whether type detection used is dynamic or static: that is,
* whether actual runtime type is used (dynamic), or just the
* declared type (static).
*<p>
* Note that Jackson 2.3 changed default to <code>DEFAULT_TYPING</code>,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * which is roughly same as saying "whatever".
* This is important as it allows avoiding accidental overrides
* at property level.
*/
public Typing typing() default Typing.DEFAULT_TYPING;
// // // Annotations for specifying intermediate Converters (2.2+)
/**
* Which helper object is to be used to convert type into something
* that Jackson knows how to serialize; either because base type
* can not be serialized easily, or just to alter serialization.
*
* @since 2.2
*/
public Class<? extends Converter<?,?>> converter() default Converter.None.class;
/**
* Similar to {@link #converter}, but used for values of structures types
* (List, arrays, Maps).
* Note that this property does NOT have effect when used as Class annotation;
* it can only be used as property annotation: this because association between
* container and value types is loose and as such converters seldom make sense
* for such usage.
*
* @since 2.2
*/
public Class<? extends Converter<?,?>> contentConverter() default Converter.None.class;
// // // Annotation(s) for inclusion criteria
/**
* Which properties of annotated Bean are
* to be included in serialization (has no effect on other types
* like enums, primitives or collections).
* Choices are "all", "properties that have value other than null"
* and "properties that have non-default value" (i.e. default value
* being property setting for a Bean constructed with default no-arg
* constructor, often null).
*<p>
* Note that Jackson 2.3 changed default to <code>DEFAULT_INCLUSION</code>,
* which is roughly same as saying "whatever". This is important because
* it allows hierarchic default values to be used.
*
* @deprecated As of Jackson 2.0, this annotation has been replaced
* by {@link com.fasterxml.jackson.annotation.JsonInclude}
*/
@Deprecated
public Inclusion include() default Inclusion.DEFAULT_INCLUSION;
/*
/**********************************************************
/* Value enumerations needed
/**********************************************************
*/
/**
* Enumeration used with {@link JsonSerialize#include} property
* to define which properties
* of
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>standardStringKey;
}
protected MapDeserializer(MapDeserializer src,
KeyDeserializer keyDeser, JsonDeserializer<Object> valueDeser,
TypeDeserializer valueTypeDeser,
HashSet<String> ignorable)
{
super(src._mapType);
_mapType = src._mapType;
_keyDeserializer = keyDeser;
_valueDeserializer = valueDeser;
_valueTypeDeserializer = valueTypeDeser;
_valueInstantiator = src._valueInstantiator;
_propertyBasedCreator = src._propertyBasedCreator;
_delegateDeserializer = src._delegateDeserializer;
_hasDefaultCreator = src._hasDefaultCreator;
_ignorableProperties = ignorable;
_standardStringKey = _isStdKeyDeser(_mapType, keyDeser);
}
/**
* Fluent factory method used to create a copy with slightly
* different settings. When sub-classing, MUST be overridden.
*/
@SuppressWarnings("unchecked")
protected MapDeserializer withResolved(KeyDeserializer keyDeser,
TypeDeserializer valueTypeDeser, JsonDeserializer<?> valueDeser,
HashSet<String> ignorable)
{
if ((_keyDeserializer == keyDeser) && (_valueDeserializer == valueDeser)
&& (_valueTypeDeserializer == valueTypeDeser) && (_ignorableProperties == ignorable)) {
return this;
}
return new MapDeserializer(this,
keyDeser, (JsonDeserializer<Object>) valueDeser, valueTypeDeser, ignorable);
}
/**
* Helper method used to check whether we can just use the default key
* deserialization, where JSON String becomes Java String.
*/
protected final boolean _isStdKeyDeser(JavaType mapType, KeyDeserializer keyDeser)
{
if (keyDeser == null) {
return true;
}
JavaType keyType = mapType.getKeyType();
if (keyType == null) { // assumed to be Object
return true;
}
Class<?> rawKeyType = keyType.getRawClass();
return ((rawKeyType == String.class || rawKeyType == Object.class)
&& isDefaultKeyDeserializer(keyDeser));
}
public void setIgnorableProperties(String[] ignorable) {
_ignorableProperties = (ignorable == null || ignorable.length == 0) ?
null :
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> ArrayBuilders.arrayToSet(ignorable);
}
/*
/**********************************************************
/* Validation, post-processing (ResolvableDeserializer)
/**********************************************************
*/
@Override
public void resolve(DeserializationContext ctxt) throws JsonMappingException
{
// May need to resolve types for delegate- and/or property-based creators:
if (_valueInstantiator.canCreateUsingDelegate()) {
JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig());
if (delegateType == null) {
throw new IllegalArgumentException("Invalid delegate-creator definition for "+_mapType
+": value instantiator ("+_valueInstantiator.getClass().getName()
+") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
}
/* Theoretically should be able to get CreatorProperty for delegate
* parameter to pass; but things get tricky because DelegateCreator
* may contain injectable values. So, for now, let's pass nothing.
*/
_delegateDeserializer = findDeserializer(ctxt, delegateType, null);
}
if (_valueInstantiator.canCreateFromObjectWith()) {
SettableBeanProperty[] creatorProps = _valueInstantiator.getFromObjectArguments(ctxt.getConfig());
_propertyBasedCreator = PropertyBasedCreator.construct(ctxt, _valueInstantiator, creatorProps);
}
_standardStringKey = _isStdKeyDeser(_mapType, _keyDeserializer);
}
/**
* Method called to finalize setup of this deserializer,
* when it is known for which property deserializer is needed for.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
KeyDeserializer kd = _keyDeserializer;
if (kd == null) {
kd = ctxt.findKeyDeserializer(_mapType.getKeyType(), property);
} else {
if (kd instanceof ContextualKeyDeserializer) {
kd = ((ContextualKeyDeserializer) kd).createContextual(ctxt, property);
}
}
JsonDeserializer<?> vd = _valueDeserializer;
// #125: May have a content converter
if (property != null) {
vd = findConvertingContentDeserializer(ctxt, property, vd);
}
final JavaType vt = _mapType.getContentType();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.std.StaticListSerializerBase;
/**
* Efficient implement for serializing {@link List}s that contains Strings and are random-accessible.
* The only complexity is due to possibility that serializer for {@link String}
* may be overridde; because of this, logic is needed to ensure that the default
* serializer is in use to use fastest mode, or if not, to defer to custom
* String serializer.
*/
@JacksonStdImpl
public final class IndexedStringListSerializer
extends StaticListSerializerBase<List<String>>
implements ContextualSerializer
{
private static final long serialVersionUID = 1L;
public final static IndexedStringListSerializer instance = new IndexedStringListSerializer();
protected final JsonSerializer<String> _serializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected IndexedStringListSerializer() { this(null); }
@SuppressWarnings("unchecked")
public IndexedStringListSerializer(JsonSerializer<?> ser) {
super(List.class);
_serializer = (JsonSerializer<String>) ser;
}
@Override protected JsonNode contentSchema() { return createSchemaNode("string", true); }
@Override
protected void acceptContentVisitor(JsonArrayFormatVisitor visitor) throws JsonMappingException {
visitor.itemsFormat(JsonFormatTypes.STRING);
}
/*
/**********************************************************
/* Post-processing
/**********************************************************
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property) throws JsonMappingException
{
/* 29-Sep-2012, tatu: Actually,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> we need to do much more contextual
* checking here since we finally know for sure the property,
* and it may have overrides
*/
JsonSerializer<?> ser = null;
// First: if we have a property, may have property-annotation overrides
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null) {
Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m);
if (serDef != null) {
ser = provider.serializerInstance(m, serDef);
}
}
}
if (ser == null) {
ser = _serializer;
}
// #124: May have a content converter
ser = findConvertingContentSerializer(provider, property, ser);
if (ser == null) {
ser = provider.findValueSerializer(String.class, property);
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
// Optimization: default serializer just writes String, so we can avoid a call:
if (isDefaultSerializer(ser)) {
ser = null;
}
// note: will never have TypeSerializer, because Strings are "natural" type
if (ser == _serializer) {
return this;
}
return new IndexedStringListSerializer(ser);
}
/*
/**********************************************************
/* Actual serialization
/**********************************************************
*/
@Override
public void serialize(List<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.size();
// [JACKSON-805]
if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) {
_serializeUnwrapped(value, jgen, provider);
return;
}
jgen.writeStartArray(len);
if (_serializer == null) {
serializeContents(value, jgen, provider, len);
} else {
serializeUsingCustom(value, jgen, provider, len);
}
jgen.writeEndArray();
}
private final void _serializeUnwrapped(List<String> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
if (_serializer == null) {
serializeContents(value, jgen
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.std.StaticListSerializerBase;
/**
* Efficient implement for serializing {@link Collection}s that contain Strings.
* The only complexity is due to possibility that serializer for {@link String}
* may be overridde; because of this, logic is needed to ensure that the default
* serializer is in use to use fastest mode, or if not, to defer to custom
* String serializer.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class StringCollectionSerializer
extends StaticListSerializerBase<Collection<String>>
implements ContextualSerializer
{
public final static StringCollectionSerializer instance = new StringCollectionSerializer();
protected final JsonSerializer<String> _serializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected StringCollectionSerializer() {
this(null);
}
@SuppressWarnings("unchecked")
protected StringCollectionSerializer(JsonSerializer<?> ser)
{
super(Collection.class);
_serializer = (JsonSerializer<String>) ser;
}
@Override protected JsonNode contentSchema() {
return createSchemaNode("string", true);
}
@Override
protected void acceptContentVisitor(JsonArrayFormatVisitor visitor)
throws JsonMappingException
{
visitor.itemsFormat(JsonFormatTypes.STRING);
}
/*
/**********************************************************
/* Post-processing
/**********************************************************
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property)
throws JsonMappingException
{
/* 29-Sep-2012, tatu: Actually, we need to do much more context
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>ual
* checking here since we finally know for sure the property,
* and it may have overrides
*/
JsonSerializer<?> ser = null;
// First: if we have a property, may have property-annotation overrides
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null) {
Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m);
if (serDef != null) {
ser = provider.serializerInstance(m, serDef);
}
}
}
if (ser == null) {
ser = _serializer;
}
// #124: May have a content converter
ser = findConvertingContentSerializer(provider, property, ser);
if (ser == null) {
ser = provider.findValueSerializer(String.class, property);
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
// Optimization: default serializer just writes String, so we can avoid a call:
if (isDefaultSerializer(ser)) {
ser = null;
}
// note: will never have TypeSerializer, because Strings are "natural" type
if (ser == _serializer) {
return this;
}
return new StringCollectionSerializer(ser);
}
/*
/**********************************************************
/* Actual serialization
/**********************************************************
*/
@Override
public void serialize(Collection<String> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
// [JACKSON-805]
final int len = value.size();
if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) {
_serializeUnwrapped(value, jgen, provider);
return;
}
jgen.writeStartArray(len);
if (_serializer == null) {
serializeContents(value, jgen, provider);
} else {
serializeUsingCustom(value, jgen, provider);
}
jgen.writeEndArray();
}
private final void _serializeUnwrapped(Collection<String> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
if (_serializer == null) {
serializeContents(value, jgen,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> }
public int getAnnotationCount() { return 0; }
@Override
public int hashCode() {
return _name.hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
VirtualAnnotatedMember other = (VirtualAnnotatedMember) o;
return (other._declaringClass == _declaringClass)
&& other._name.equals(_name);
}
@Override
public String toString() {
return "[field "+getFullName()+"]";
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
@SuppressWarnings("serial")
public class UnknownSerializer
extends StdSerializer<Object>
{
public UnknownSerializer() {
super(Object.class);
}
@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonMappingException
{
// 27-Nov-2009, tatu: As per [JACKSON-201] may or may not fail...
if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) {
failForEmpty(value);
}
// But if it's fine, we'll just output empty JSON Object:
jgen.writeStartObject();
jgen.writeEndObject();
}
@Override
public final void serializeWithType(Object value, JsonGenerator jgen, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException, JsonGenerationException
{
if (provider.isEnabled(SerializationFeature.FAIL_ON_EMPTY_BEANS)) {
failForEmpty(value);
}
typeSer.writeTypePrefixForObject(value, jgen);
typeSer.writeTypeSuffixForObject(value, jgen);
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException {
return null;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
visitor.expectAnyFormat(typeHint);
}
protected void failForEmpty(Object value) throws JsonMappingException
{
throw new JsonMappingException("No serializer found for class "+value.getClass().getName()+" and no properties discovered to create BeanSerializer (to avoid exception, disable SerializationFeature.FAIL_ON_EMPTY_BEANS) )");
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect;
import java.util.Collection;
import java.util.Map;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.type.SimpleType;
import com.fasterxml.jackson.databind.util.LRUMap;
public class BasicClassIntrospector
extends ClassIntrospector
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
/* We keep a small set of pre-constructed descriptions to use for
* common non-structured values, such as Numbers and Strings.
* This is strictly performance optimization to reduce what is
* usually one-time cost, but seems useful for some cases considering
* simplicity.
*
* @since 2.4
*/
protected final static BasicBeanDescription STRING_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(String.class, null, null);
STRING_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(String.class), ac);
}
protected final static BasicBeanDescription BOOLEAN_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Boolean.TYPE, null, null);
BOOLEAN_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Boolean.TYPE), ac);
}
protected final static BasicBeanDescription INT_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Integer.TYPE, null, null);
INT_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Integer.TYPE), ac);
}
protected final static BasicBeanDescription LONG_DESC;
static {
AnnotatedClass ac = AnnotatedClass.constructWithoutSuperTypes(Long.TYPE, null, null);
LONG_DESC = BasicBeanDescription.forOtherUse(null, SimpleType.constructUnsafe(Long.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> cls = type.getRawClass();
if (cls.isPrimitive()) {
if (cls == Boolean.TYPE) {
return BOOLEAN_DESC;
}
if (cls == Integer.TYPE) {
return INT_DESC;
}
if (cls == Long.TYPE) {
return LONG_DESC;
}
} else {
if (cls == String.class) {
return STRING_DESC;
}
}
return null;
}
/**
* Helper method used to decide whether we can omit introspection
* for members (methods, fields, constructors); we may do so for
* a limited number of container types JDK provides.
*/
protected boolean _isStdJDKCollection(JavaType type)
{
if (!type.isContainerType() || type.isArrayType()) {
return false;
}
Class<?> raw = type.getRawClass();
Package pkg = raw.getPackage();
if (pkg != null) {
String pkgName = pkg.getName();
if (pkgName.startsWith("java.lang")
|| pkgName.startsWith("java.util")) {
/* 23-Sep-2014, tatu: Should we be conservative here (minimal number
* of matches), or ambitious? Let's do latter for now.
*/
if (Collection.class.isAssignableFrom(raw)
|| Map.class.isAssignableFrom(raw)) {
return true;
}
}
}
return false;
}
protected BasicBeanDescription _findStdJdkCollectionDesc(MapperConfig<?> cfg,
JavaType type, MixInResolver r)
{
if (_isStdJDKCollection(type)) {
AnnotatedClass ac = AnnotatedClass.construct(type.getRawClass(),
(cfg.isAnnotationProcessingEnabled() ? cfg.getAnnotationIntrospector() : null), r);
return BasicBeanDescription.forOtherUse(cfg, type, ac);
}
return null;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.impl.ObjectIdReader;
import com.fasterxml.jackson.databind.deser.impl.ReadableObjectId;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Deserializer only used for abstract types used as placeholders during polymorphic
* type handling deserialization. If so, there is no real deserializer associated
* with nominal type, just {@link TypeDeserializer}; and any calls that do not
* pass such resolver will result in an error.
*/
public class AbstractDeserializer
extends JsonDeserializer<Object>
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
protected final JavaType _baseType;
protected final ObjectIdReader _objectIdReader;
protected final Map<String, SettableBeanProperty> _backRefProperties;
// support for "native" types, which require special care:
protected final boolean _acceptString;
protected final boolean _acceptBoolean;
protected final boolean _acceptInt;
protected final boolean _acceptDouble;
public AbstractDeserializer(BeanDeserializerBuilder builder,
BeanDescription beanDesc, Map<String, SettableBeanProperty> backRefProps)
{
_baseType = beanDesc.getType();
_objectIdReader = builder.getObjectIdReader();
_backRefProperties = backRefProps;
Class<?> cls = _baseType.getRawClass();
_acceptString = cls.isAssignableFrom(String.class);
_acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean.class);
_acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class);
_acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class);
}
protected AbstractDeserializer(BeanDescription beanDesc)
{
_baseType = beanDesc.getType();
_objectIdReader = null;
_backRefProperties = null;
Class<?> cls = _baseType.getRawClass();
_acceptString = cls.isAssignableFrom(String.class);
_acceptBoolean = (cls == Boolean.TYPE) || cls.isAssignableFrom(Boolean
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.class);
_acceptInt = (cls == Integer.TYPE) || cls.isAssignableFrom(Integer.class);
_acceptDouble = (cls == Double.TYPE) || cls.isAssignableFrom(Double.class);
}
/**
* Factory method used when constructing instances for non-POJO types, like
* {@link java.util.Map}s.
*
* @since 2.3
*/
public static AbstractDeserializer constructForNonPOJO(BeanDescription beanDesc) {
return new AbstractDeserializer(beanDesc);
}
/*
/**********************************************************
/* Public accessors
/**********************************************************
*/
@Override
public Class<?> handledType() {
return _baseType.getRawClass();
}
@Override
public boolean isCachable() { return true; }
/**
* Overridden to return true for those instances that are
* handling value for which Object Identity handling is enabled
* (either via value type or referring property).
*/
@Override
public ObjectIdReader getObjectIdReader() {
return _objectIdReader;
}
/**
* Method called by <code>BeanDeserializer</code> to resolve back reference
* part of managed references.
*/
@Override
public SettableBeanProperty findBackReference(String logicalName) {
return (_backRefProperties == null) ? null : _backRefProperties.get(logicalName);
}
/*
/**********************************************************
/* Deserializer implementation
/**********************************************************
*/
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException, JsonProcessingException
{
// Hmmh. One tricky question; for scalar, is it an Object Id, or "Natural" type?
// for now, prefer Object Id:
if (_objectIdReader != null) {
JsonToken t = jp.getCurrentToken();
// should be good enough check; we only care about Strings, integral numbers:
if (t != null && t.isScalarValue()) {
return _deserializeFromObjectId(jp, ctxt);
}
}
// First: support "natural" values (which are always serialized without type info!)
Object result = _deserializeIfNatural(jp, ctxt);
if (result != null) {
return result;
}
return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>AnnotatedMember m) {
Boolean r = _primary.hasRequiredMarker(m);
return (r == null) ? _secondary.hasRequiredMarker(m) : r;
}
// // // Serialization: general annotations
@Override
public Object findSerializer(Annotated am) {
Object r = _primary.findSerializer(am);
return _isExplicitClassOrOb(r, JsonSerializer.None.class)
? r : _secondary.findSerializer(am);
}
@Override
public Object findKeySerializer(Annotated a) {
Object r = _primary.findKeySerializer(a);
return _isExplicitClassOrOb(r, JsonSerializer.None.class)
? r : _secondary.findKeySerializer(a);
}
@Override
public Object findContentSerializer(Annotated a) {
Object r = _primary.findContentSerializer(a);
return _isExplicitClassOrOb(r, JsonSerializer.None.class)
? r : _secondary.findContentSerializer(a);
}
@Override
public Object findNullSerializer(Annotated a) {
Object r = _primary.findNullSerializer(a);
return _isExplicitClassOrOb(r, JsonSerializer.None.class)
? r : _secondary.findNullSerializer(a);
}
@Override
public JsonInclude.Include findSerializationInclusion(Annotated a,
JsonInclude.Include defValue)
{
// note: call secondary first, to give lower priority
defValue = _secondary.findSerializationInclusion(a, defValue);
defValue = _primary.findSerializationInclusion(a, defValue);
return defValue;
}
@Override
public JsonInclude.Include findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue)
{
// note: call secondary first, to give lower priority
defValue = _secondary.findSerializationInclusion(a, defValue);
defValue = _primary.findSerializationInclusion(a, defValue);
return defValue;
}
@Override
public Class<?> findSerializationType(Annotated a) {
Class<?> r = _primary.findSerializationType(a);
return (r == null) ? _secondary.findSerializationType(a) : r;
}
@Override
public Class<?> findSerializationKeyType(Annotated am,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
*/
@Override
@Deprecated
public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) {
Boolean r = _primary.findSerializationSortAlphabetically(ac);
return (r == null) ? _secondary.findSerializationSortAlphabetically(ac) : r;
}
@Override
public Boolean findSerializationSortAlphabetically(Annotated ann) {
Boolean r = _primary.findSerializationSortAlphabetically(ann);
return (r == null) ? _secondary.findSerializationSortAlphabetically(ann) : r;
}
@Override
public void findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac,
List<BeanPropertyWriter> properties) {
// first secondary, then primary, to give proper precedence
_primary.findAndAddVirtualProperties(config, ac, properties);
_secondary.findAndAddVirtualProperties(config, ac, properties);
}
// // // Serialization: property annotations
@Override
public PropertyName findNameForSerialization(Annotated a) {
PropertyName n = _primary.findNameForSerialization(a);
// note: "use default" should not block explicit answer, so:
if (n == null) {
n = _secondary.findNameForSerialization(a);
} else if (n == PropertyName.USE_DEFAULT) {
PropertyName n2 = _secondary.findNameForSerialization(a);
if (n2 != null) {
n = n2;
}
}
return n;
}
@Override
public boolean hasAsValueAnnotation(AnnotatedMethod am) {
return _primary.hasAsValueAnnotation(am) || _secondary.hasAsValueAnnotation(am);
}
@Override
public String findEnumValue(Enum<?> value) {
String r = _primary.findEnumValue(value);
return (r == null) ? _secondary.findEnumValue(value) : r;
}
// // // Deserialization: general annotations
@Override
public Object findDeserializer(Annotated am) {
Object r = _primary.findDeserializer(am);
return _isExplicitClassOrOb(r, JsonDeserializer.None.class)
? r : _secondary.findDeserializer(am);
}
@Override
public Object findKeyDeserializer(Annotated am) {
Object r = _primary.findKeyDeserializer(am);
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> _isExplicitClassOrOb(r, KeyDeserializer.None.class)
? r : _secondary.findKeyDeserializer(am);
}
@Override
public Object findContentDeserializer(Annotated am) {
Object r = _primary.findContentDeserializer(am);
return _isExplicitClassOrOb(r, JsonDeserializer.None.class)
? r : _secondary.findContentDeserializer(am);
}
@Override
public Class<?> findDeserializationType(Annotated am, JavaType baseType) {
Class<?> r = _primary.findDeserializationType(am, baseType);
return (r != null) ? r : _secondary.findDeserializationType(am, baseType);
}
@Override
public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType) {
Class<?> result = _primary.findDeserializationKeyType(am, baseKeyType);
return (result == null) ? _secondary.findDeserializationKeyType(am, baseKeyType) : result;
}
@Override
public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType) {
Class<?> result = _primary.findDeserializationContentType(am, baseContentType);
return (result == null) ? _secondary.findDeserializationContentType(am, baseContentType) : result;
}
@Override
public Object findDeserializationConverter(Annotated a) {
Object ob = _primary.findDeserializationConverter(a);
return (ob == null) ? _secondary.findDeserializationConverter(a) : ob;
}
@Override
public Object findDeserializationContentConverter(AnnotatedMember a) {
Object ob = _primary.findDeserializationContentConverter(a);
return (ob == null) ? _secondary.findDeserializationContentConverter(a) : ob;
}
// // // Deserialization: class annotations
@Override
public Object findValueInstantiator(AnnotatedClass ac) {
Object result = _primary.findValueInstantiator(ac);
return (result == null) ? _secondary.findValueInstantiator(ac) : result;
}
@Override
public Class<?> findPOJOBuilder(AnnotatedClass ac) {
Class<?> result = _primary.findPOJOBuilder(ac);
return (result == null) ? _secondary.findPOJOBuilder(ac) : result;
}
@Override
public JsonPOJOBuilder.Value findPOJO
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> _typeNames = null;
_typeParameters = null;
} else {
_typeNames = typeNames;
_typeParameters = typeParams;
}
_typeParametersFor = parametersFrom;
}
/**
* Method used by core Jackson classes: NOT to be used by application code.
*<p>
* NOTE: public only because it is called by <code>ObjectMapper</code> which is
* not in same package
*/
public static SimpleType constructUnsafe(Class<?> raw) {
return new SimpleType(raw, null, null, null, null, false, null);
}
@Override
protected JavaType _narrow(Class<?> subclass)
{
// Should we check that there is a sub-class relationship?
return new SimpleType(subclass, _typeNames, _typeParameters, _valueHandler, _typeHandler,
_asStatic, _typeParametersFor);
}
@Override
public JavaType narrowContentsBy(Class<?> subclass)
{
// should never get called
throw new IllegalArgumentException("Internal error: SimpleType.narrowContentsBy() should never be called");
}
@Override
public JavaType widenContentsBy(Class<?> subclass)
{
// should never get called
throw new IllegalArgumentException("Internal error: SimpleType.widenContentsBy() should never be called");
}
public static SimpleType construct(Class<?> cls)
{
/* Let's add sanity checks, just to ensure no
* Map/Collection entries are constructed
*/
if (Map.class.isAssignableFrom(cls)) {
throw new IllegalArgumentException("Can not construct SimpleType for a Map (class: "+cls.getName()+")");
}
if (Collection.class.isAssignableFrom(cls)) {
throw new IllegalArgumentException("Can not construct SimpleType for a Collection (class: "+cls.getName()+")");
}
// ... and while we are at it, not array types either
if (cls.isArray()) {
throw new IllegalArgumentException("Can not construct SimpleType for an array (class: "+cls.getName()+")");
}
return new SimpleType(cls);
}
@Override
public SimpleType withTypeHandler(Object h)
{
return new SimpleType(_class, _typeNames, _typeParameters, _valueHandler, h, _asStatic, _typeParametersFor);
}
@
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Override
public JavaType withContentTypeHandler(Object h) {
// no content type, so:
throw new IllegalArgumentException("Simple types have no content types; can not call withContenTypeHandler()");
}
@Override
public SimpleType withValueHandler(Object h) {
if (h == _valueHandler) {
return this;
}
return new SimpleType(_class, _typeNames, _typeParameters, h, _typeHandler, _asStatic, _typeParametersFor);
}
@Override
public SimpleType withContentValueHandler(Object h) {
// no content type, so:
throw new IllegalArgumentException("Simple types have no content types; can not call withContenValueHandler()");
}
@Override
public SimpleType withStaticTyping() {
return _asStatic ? this : new SimpleType(_class,
_typeNames, _typeParameters, _valueHandler, _typeHandler, _asStatic, _typeParametersFor);
}
@Override
protected String buildCanonicalName()
{
StringBuilder sb = new StringBuilder();
sb.append(_class.getName());
if (_typeParameters != null && _typeParameters.length > 0) {
sb.append('<');
boolean first = true;
for (JavaType t : _typeParameters) {
if (first) {
first = false;
} else {
sb.append(',');
}
sb.append(t.toCanonical());
}
sb.append('>');
}
return sb.toString();
}
/*
/**********************************************************
/* Public API
/**********************************************************
*/
@Override
public boolean isContainerType() { return false; }
@Override
public int containedTypeCount() {
return (_typeParameters == null) ? 0 : _typeParameters.length;
}
@Override
public JavaType containedType(int index)
{
if (index < 0 || _typeParameters == null || index >= _typeParameters.length) {
return null;
}
return _typeParameters[index];
}
@Override
public String containedTypeName(int index)
{
if (index < 0 || _typeNames == null || index >= _typeNames.length) {
return null;
}
return _typeNames[index];
}
@Override
public Class<?> getParameterSource
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>() {
return _typeParametersFor;
}
@Override
public StringBuilder getErasedSignature(StringBuilder sb) {
return _classSignature(_class, sb, true);
}
@Override
public StringBuilder getGenericSignature(StringBuilder sb)
{
_classSignature(_class, sb, false);
if (_typeParameters != null) {
sb.append('<');
for (JavaType param : _typeParameters) {
sb = param.getGenericSignature(sb);
}
sb.append('>');
}
sb.append(';');
return sb;
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public String toString()
{
StringBuilder sb = new StringBuilder(40);
sb.append("[simple type, class ").append(buildCanonicalName()).append(']');
return sb.toString();
}
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
SimpleType other = (SimpleType) o;
// Classes must be identical...
if (other._class != this._class) return false;
// And finally, generic bindings, if any
JavaType[] p1 = _typeParameters;
JavaType[] p2 = other._typeParameters;
if (p1 == null) {
return (p2 == null) || p2.length == 0;
}
if (p2 == null) return false;
if (p1.length != p2.length) return false;
for (int i = 0, len = p1.length; i < len; ++i) {
if (!p1[i].equals(p2[i])) {
return false;
}
}
return true;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
/**
* Helper class that contains functionality needed by both serialization
* and deserialization side.
*/
public class BeanUtil
{
/*
/**********************************************************
/* Handling property names
/**********************************************************
*/
/**
* @since 2.5
*/
public static String okNameForGetter(AnnotatedMethod am, boolean stdNaming) {
String name = am.getName();
String str = okNameForIsGetter(am, name, stdNaming);
if (str == null) {
str = okNameForRegularGetter(am, name, stdNaming);
}
return str;
}
/**
* @since 2.5
*/
public static String okNameForRegularGetter(AnnotatedMethod am, String name,
boolean stdNaming)
{
if (name.startsWith("get")) {
/* 16-Feb-2009, tatu: To handle [JACKSON-53], need to block
* CGLib-provided method "getCallbacks". Not sure of exact
* safe criteria to get decent coverage without false matches;
* but for now let's assume there's no reason to use any
* such getter from CGLib.
* But let's try this approach...
*/
if ("getCallbacks".equals(name)) {
if (isCglibGetCallbacks(am)) {
return null;
}
} else if ("getMetaClass".equals(name)) {
// 30-Apr-2009, tatu: Need to suppress serialization of a cyclic reference
if (isGroovyMetaClassGetter(am)) {
return null;
}
}
return stdNaming
? stdManglePropertyName(name, 3)
: legacyManglePropertyName(name, 3);
}
return null;
}
/**
* @since 2.5
*/
public static String okNameForIsGetter(AnnotatedMethod am, String name,
boolean stdNaming)
{
if (name.startsWith("is")) { // plus, must return a boolean
Class<?> rt = am.getRawType();
if (rt == Boolean.class || rt == Boolean.TYPE) {
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>getParameterCount() != 1) {
continue;
}
_doAddInjectable(ai.findInjectableValueId(m), m);
}
}
protected void _doAddInjectable(Object id, AnnotatedMember m)
{
if (id == null) {
return;
}
if (_injectables == null) {
_injectables = new LinkedHashMap<Object, AnnotatedMember>();
}
AnnotatedMember prev = _injectables.put(id, m);
if (prev != null) {
String type = id.getClass().getName();
throw new IllegalArgumentException("Duplicate injectable value with id '"
+String.valueOf(id)+"' (of type "+type+")");
}
}
private PropertyName _propNameFromSimple(String simpleName) {
return PropertyName.construct(simpleName, null);
}
/*
/**********************************************************
/* Internal methods; removing ignored properties
/**********************************************************
*/
/**
* Method called to get rid of candidate properties that are marked
* as ignored, or that are not visible.
*/
protected void _removeUnwantedProperties()
{
Iterator<Map.Entry<String,POJOPropertyBuilder>> it = _properties.entrySet().iterator();
final boolean forceNonVisibleRemoval = !_config.isEnabled(MapperFeature.INFER_PROPERTY_MUTATORS);
while (it.hasNext()) {
Map.Entry<String, POJOPropertyBuilder> entry = it.next();
POJOPropertyBuilder prop = entry.getValue();
// First: if nothing visible, just remove altogether
if (!prop.anyVisible()) {
it.remove();
continue;
}
// Otherwise, check ignorals
if (prop.anyIgnorals()) {
// first: if one or more ignorals, and no explicit markers, remove the whole thing
if (!prop.isExplicitlyIncluded()) {
it.remove();
_addIgnored(prop.getName());
continue;
}
// otherwise just remove ones marked to be ignored
prop.removeIgnored();
if (!_forSerialization && !prop.couldDeserialize()) {
_addIgnored(prop.getName());
}
}
// and finally, handle removal of individual non-visible elements
prop.removeNonVisible(forceNonVisibleRemoval);
}
}
private void _addIgnored(String name
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>prop == null) {
prop = new POJOPropertyBuilder(new PropertyName(implName),
_annotationIntrospector, _forSerialization);
_properties.put(implName, prop);
}
return prop;
}
private PropertyNamingStrategy _findNamingStrategy()
{
Object namingDef = (_annotationIntrospector == null)? null
: _annotationIntrospector.findNamingStrategy(_classDef);
if (namingDef == null) {
return _config.getPropertyNamingStrategy();
}
if (namingDef instanceof PropertyNamingStrategy) {
return (PropertyNamingStrategy) namingDef;
}
/* Alas, there's no way to force return type of "either class
* X or Y" -- need to throw an exception after the fact
*/
if (!(namingDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned PropertyNamingStrategy definition of type "
+namingDef.getClass().getName()+"; expected type PropertyNamingStrategy or Class<PropertyNamingStrategy> instead");
}
Class<?> namingClass = (Class<?>)namingDef;
if (!PropertyNamingStrategy.class.isAssignableFrom(namingClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "
+namingClass.getName()+"; expected Class<PropertyNamingStrategy>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
if (hi != null) {
PropertyNamingStrategy pns = hi.namingStrategyInstance(_config, _classDef, namingClass);
if (pns != null) {
return pns;
}
}
return (PropertyNamingStrategy) ClassUtil.createInstance(namingClass,
_config.canOverrideAccessModifiers());
}
protected void _updateCreatorProperty(POJOPropertyBuilder prop, List<POJOPropertyBuilder> creatorProperties) {
if (creatorProperties != null) {
for (int i = 0, len = creatorProperties.size(); i < len; ++i) {
if (creatorProperties.get(i).getInternalName().equals(prop.getInternalName())) {
creatorProperties.set(i, prop);
break;
}
}
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.util.Collection;
import com.fasterxml.jackson.databind.JavaType;
/**
* Type that represents things that act similar to {@link java.util.Collection};
* but may or may not be instances of that interface.
* This specifically allows framework to check for configuration and annotation
* settings used for Map types, and pass these to custom handlers that may be more
* familiar with actual type.
*/
public class CollectionLikeType extends TypeBase
{
private static final long serialVersionUID = 4611641304150899138L;
/**
* Type of elements in collection
*/
protected final JavaType _elementType;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected CollectionLikeType(Class<?> collT, JavaType elemT,
Object valueHandler, Object typeHandler, boolean asStatic)
{
super(collT, elemT.hashCode(), valueHandler, typeHandler, asStatic);
_elementType = elemT;
}
@Override
protected JavaType _narrow(Class<?> subclass) {
return new CollectionLikeType(subclass, _elementType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType narrowContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _elementType.getRawClass()) {
return this;
}
return new CollectionLikeType(_class, _elementType.narrowBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType widenContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _elementType.getRawClass()) {
return this;
}
return new CollectionLikeType(_class, _elementType.widenBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
public static CollectionLikeType construct(Class<?> rawType, JavaType elemT)
{
// nominally component types will be just Object.class
return new CollectionLikeType(rawType, elemT, null, null, false);
}
@Override
public CollectionLikeType withTypeHandler(Object
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> h)
{
return new CollectionLikeType(_class, _elementType, _valueHandler, h, _asStatic);
}
@Override
public CollectionLikeType withContentTypeHandler(Object h)
{
return new CollectionLikeType(_class, _elementType.withTypeHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withValueHandler(Object h) {
return new CollectionLikeType(_class, _elementType, h, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withContentValueHandler(Object h) {
return new CollectionLikeType(_class, _elementType.withValueHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public CollectionLikeType withStaticTyping() {
if (_asStatic) {
return this;
}
return new CollectionLikeType(_class, _elementType.withStaticTyping(),
_valueHandler, _typeHandler, true);
}
/*
/**********************************************************
/* Public API
/**********************************************************
*/
@Override
public boolean isContainerType() { return true; }
@Override
public boolean isCollectionLikeType() { return true; }
@Override
public JavaType getContentType() { return _elementType; }
@Override
public int containedTypeCount() { return 1; }
@Override
public JavaType containedType(int index) {
return (index == 0) ? _elementType : null;
}
/**
* Not sure if we should count on this, but type names
* for core interfaces use "E" for element type
*/
@Override
public String containedTypeName(int index) {
if (index == 0) return "E";
return null;
}
// TODO: should allow construction of instances that do refer
// to parameterization, since it is NOT Collection
@Override
public Class<?> getParameterSource() {
return null;
}
@Override
public StringBuilder getErasedSignature(StringBuilder sb) {
return _classSignature(_class, sb, true);
}
@Override
public StringBuilder getGenericSignature(StringBuilder sb) {
_classSignature(_class, sb, false);
sb.append('<');
_elementType.getGenericSignature(sb);
sb.append
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(">;");
return sb;
}
@Override
protected String buildCanonicalName() {
StringBuilder sb = new StringBuilder();
sb.append(_class.getName());
if (_elementType != null) {
sb.append('<');
sb.append(_elementType.toCanonical());
sb.append('>');
}
return sb.toString();
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Method that can be used for checking whether this type is a
* "real" Collection type; meaning whether it represents a parameterized
* subtype of {@link java.util.Collection} or just something that acts
* like one.
*/
public boolean isTrueCollectionType() {
return Collection.class.isAssignableFrom(_class);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
CollectionLikeType other = (CollectionLikeType) o;
return (_class == other._class) && _elementType.equals(other._elementType);
}
@Override
public String toString()
{
return "[collection-like type; class "+_class.getName()+", contains "+_elementType+"]";
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
@JacksonStdImpl
public final class StringDeserializer extends StdScalarDeserializer<String>
{
private static final long serialVersionUID = 1L;
/**
* @since 2.2
*/
public final static StringDeserializer instance = new StringDeserializer();
public StringDeserializer() { super(String.class); }
@Override
public String deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
JsonToken curr = jp.getCurrentToken();
if (curr == JsonToken.VALUE_STRING) {
return jp.getText();
}
// Issue#381
if (curr == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
jp.nextToken();
final String parsed = _parseString(jp, ctxt);
if (jp.nextToken() != JsonToken.END_ARRAY) {
throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
"Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array");
}
return parsed;
}
// [JACKSON-330]: need to gracefully handle byte[] data, as base64
if (curr == JsonToken.VALUE_EMBEDDED_OBJECT) {
Object ob = jp.getEmbeddedObject();
if (ob == null) {
return null;
}
if (ob instanceof byte[]) {
return Base64Variants.getDefaultVariant().encode((byte[]) ob, false);
}
// otherwise, try conversion using toString()...
return ob.toString();
}
// allow coercions for other scalar types
String text = jp.getValueAsString();
if (text != null) {
return text;
}
throw ctxt.mappingException(_valueClass, curr);
}
// 1.6: since we can never have type info
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
public Object getTypeId() {
return getClass().getName();
}
/*
/**********************************************************
/* Life-cycle: registration
/**********************************************************
*/
/**
* Method called by {@link ObjectMapper} when module is registered.
* It is called to let module register functionality it provides,
* using callback methods passed-in context object exposes.
*/
public abstract void setupModule(SetupContext context);
/*
/**********************************************************
/* Helper types
/**********************************************************
*/
/**
* Interface Jackson exposes to modules for purpose of registering
* extended functionality.
* Usually implemented by {@link ObjectMapper}, but modules should
* NOT rely on this -- if they do require access to mapper instance,
* they need to call {@link SetupContext#getOwner} method.
*/
public static interface SetupContext
{
/*
/**********************************************************
/* Simple accessors
/**********************************************************
*/
/**
* Method that returns version information about {@link ObjectMapper}
* that implements this context. Modules can use this to choose
* different settings or initialization order; or even decide to fail
* set up completely if version is compatible with module.
*/
public Version getMapperVersion();
/**
* Fallback access method that allows modules to refer to the
* {@link ObjectMapper} that provided this context.
* It should NOT be needed by most modules; and ideally should
* not be used -- however, there may be cases where this may
* be necessary due to various design constraints.
*<p>
* NOTE: use of this method is discouraged, as it allows access to
* things Modules typically should not modify. It is included, however,
* to allow access to new features in cases where Module API
* has not yet been extended, or there are oversights.
*<p>
* Return value is chosen to not leak dependency to {@link ObjectMapper};
* however, instance will always be of that type.
* This is why return value is declared generic, to allow caller to
* specify context to often avoid casting.
*
* @since 2.0
*/
public <C extends ObjectCodec> C getOwner();
/**
* Accessor for finding {@link TypeFactory} that is currently configured
* by the context.
*<p>
* NOTE: since it is possible that other modules might change or replace
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>NullValue();
} else if (typeDeser == null) {
value = valueDes.deserialize(jp, ctxt);
} else {
value = valueDes.deserializeWithType(jp, ctxt, typeDeser);
}
} catch (Exception e) {
wrapAndThrow(e, Map.Entry.class, keyStr);
}
// Close, but also verify that we reached the END_OBJECT
t = jp.nextToken();
if (t != JsonToken.END_OBJECT) {
if (t == JsonToken.FIELD_NAME) { // most likely
throw ctxt.mappingException("Problem binding JSON into Map.Entry: more than one entry in JSON (second field: '"+jp.getCurrentName()+"')");
}
// how would this occur?
throw ctxt.mappingException("Problem binding JSON into Map.Entry: unexpected content after JSON Object entry: "+t);
}
return new AbstractMap.SimpleEntry<Object,Object>(key, value);
}
@Override
public Map.Entry<Object,Object> deserialize(JsonParser jp, DeserializationContext ctxt,
Map.Entry<Object,Object> result) throws IOException
{
throw new IllegalStateException("Can not update Map.Entry values");
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException, JsonProcessingException
{
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromObject(jp, ctxt);
}
/*
/**********************************************************
/* Other public accessors
/**********************************************************
*/
@Override public JavaType getValueType() { return _type; }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.util.*;
import java.lang.reflect.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.util.ArrayBuilders;
import com.fasterxml.jackson.databind.util.LRUMap;
/**
* Class used for creating concrete {@link JavaType} instances,
* given various inputs.
*<p>
* Instances of this class are accessible using {@link com.fasterxml.jackson.databind.ObjectMapper}
* as well as many objects it constructs (like
* {@link com.fasterxml.jackson.databind.DeserializationConfig} and
* {@link com.fasterxml.jackson.databind.SerializationConfig})),
* but usually those objects also
* expose convenience methods (<code>constructType</code>).
* So, you can do for example:
*<pre>
* JavaType stringType = mapper.constructType(String.class);
*</pre>
* However, more advanced methods are only exposed by factory so that you
* may need to use:
*<pre>
* JavaType stringCollection = mapper.getTypeFactory().constructCollectionType(List.class, String.class);
*</pre>
*/
@SuppressWarnings({"rawtypes", "unchecked"})
public final class TypeFactory
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
private final static JavaType[] NO_TYPES = new JavaType[0];
/**
* Globally shared singleton. Not accessed directly; non-core
* code should use per-ObjectMapper instance (via configuration objects).
* Core Jackson code uses {@link #defaultInstance} for accessing it.
*/
protected final static TypeFactory instance = new TypeFactory();
/*
/**********************************************************
/* Caching
/**********************************************************
*/
// // // Let's assume that a small set of core primitive/basic types
// // // will not be modified, and can be freely shared to streamline
// // // parts of processing
protected final static SimpleType CORE_TYPE_STRING = new SimpleType(String.class);
protected final static SimpleType CORE_TYPE_BOOL = new SimpleType(Boolean.TYPE);
protected final static SimpleType CORE_
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> instanceof SimpleType) {
// and only if subclass is an array, Collection or Map
if (subclass.isArray()
|| Map.class.isAssignableFrom(subclass)
|| Collection.class.isAssignableFrom(subclass)) {
// need to assert type compatibility...
if (!baseType.getRawClass().isAssignableFrom(subclass)) {
throw new IllegalArgumentException("Class "+subclass.getClass().getName()+" not subtype of "+baseType);
}
// this _should_ work, right?
JavaType subtype = _fromClass(subclass, new TypeBindings(this, baseType.getRawClass()));
// one more thing: handlers to copy?
Object h = baseType.getValueHandler();
if (h != null) {
subtype = subtype.withValueHandler(h);
}
h = baseType.getTypeHandler();
if (h != null) {
subtype = subtype.withTypeHandler(h);
}
return subtype;
}
}
// otherwise regular narrowing should work just fine
return baseType.narrowBy(subclass);
}
/**
* Factory method for constructing a {@link JavaType} out of its canonical
* representation (see {@link JavaType#toCanonical()}).
*
* @param canonical Canonical string representation of a type
*
* @throws IllegalArgumentException If canonical representation is malformed,
* or class that type represents (including its generic parameters) is
* not found
*/
public JavaType constructFromCanonical(String canonical) throws IllegalArgumentException
{
return _parser.parse(canonical);
}
/**
* Method that is to figure out actual type parameters that given
* class binds to generic types defined by given (generic)
* interface or class.
* This could mean, for example, trying to figure out
* key and value types for Map implementations.
*
* @param type Sub-type (leaf type) that implements <code>expType</code>
*/
public JavaType[] findTypeParameters(JavaType type, Class<?> expType)
{
/* Tricky part here is that some JavaType instances have been constructed
* from generic type (usually via TypeReference); and in those case
* types have been resolved. Alternative is that the leaf type is type-erased
* class, in which case this has not been done.
* For now simplest way to handle this is to split
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>>></code>, you could
* call
*<pre>
* JavaType inner = TypeFactory.parametricType(Set.class, Integer.class);
* TypeFactory.parametricType(List.class, inner);
*</pre>
*<p>
* NOTE: type modifiers are NOT called on constructed type itself; but are called
* for contained types.
*
*
* @param parametrized Actual full type
* @param parametersFor class or interface for which type parameters are applied; either
* <code>parametrized</code> or one of its supertypes
* @param parameterTypes Type parameters to apply
*
* @since 2.5
*/
public JavaType constructParametrizedType(Class<?> parametrized, Class<?> parametersFor,
JavaType... parameterTypes)
{
JavaType resultType;
// Need to check kind of class we are dealing with...
if (parametrized.isArray()) {
// 19-Jan-2010, tatus: should we support multi-dimensional arrays directly?
if (parameterTypes.length != 1) {
throw new IllegalArgumentException("Need exactly 1 parameter type for arrays ("+parametrized.getName()+")");
}
resultType = constructArrayType(parameterTypes[0]);
}
else if (Map.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 2) {
throw new IllegalArgumentException("Need exactly 2 parameter types for Map types ("+parametrized.getName()+")");
}
resultType = constructMapType((Class<Map<?,?>>)parametrized, parameterTypes[0], parameterTypes[1]);
}
else if (Collection.class.isAssignableFrom(parametrized)) {
if (parameterTypes.length != 1) {
throw new IllegalArgumentException("Need exactly 1 parameter type for Collection types ("+parametrized.getName()+")");
}
resultType = constructCollectionType((Class<Collection<?>>)parametrized, parameterTypes[0]);
} else {
resultType = constructSimpleType(parametrized, parametersFor, parameterTypes);
}
return resultType;
}
/**
* @deprecated Since 2.5, use {@link #constructParametrizedType} instead.
*/
@Deprecated
public JavaType constructParametricType(Class
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> that its
* parameterization is unknown.
* This is similar to using <code>Object.class</code> parameterization,
* and is equivalent to calling:
*<pre>
* typeFactory.constructMapLikeType(collectionClass, typeFactory.unknownType(), typeFactory.unknownType());
*<pre>
*<p>
* This method should only be used if parameterization is completely unavailable.
*/
public MapLikeType constructRawMapLikeType(Class<?> mapClass) {
return MapLikeType.construct(mapClass, unknownType(), unknownType());
}
/*
/**********************************************************
/* Actual factory methods
/**********************************************************
*/
/**
* @param context Mapping of formal parameter declarations (for generic
* types) into actual types
*/
protected JavaType _fromClass(Class<?> clz, TypeBindings context)
{
// Very first thing: small set of core types we know well:
if (clz == String.class) return CORE_TYPE_STRING;
if (clz == Boolean.TYPE) return CORE_TYPE_BOOL;
if (clz == Integer.TYPE) return CORE_TYPE_INT;
if (clz == Long.TYPE) return CORE_TYPE_LONG;
// Barring that, we may have recently constructed an instance:
ClassKey key = new ClassKey(clz);
JavaType result = _typeCache.get(key); // ok, cache object is synced
if (result != null) {
return result;
}
// If context was needed, weed do:
/*
if (context == null) {
context = new TypeBindings(this, cls);
}
*/
// First: do we have an array type?
if (clz.isArray()) {
result = ArrayType.construct(_constructType(clz.getComponentType(), null), null, null);
/* Also: although enums can also be fully resolved, there's little
* point in doing so (T extends Enum<T>) etc.
*/
} else if (clz.isEnum()) {
result = new SimpleType(clz);
/* Maps and Collections aren't quite as hot; problem is, due
* to type erasure we often do not know typing and can only assume
* base Object.
*/
} else
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (Map.class.isAssignableFrom(clz)) {
result = _mapType(clz);
} else if (Collection.class.isAssignableFrom(clz)) {
result = _collectionType(clz);
} else {
// 29-Sep-2014, tatu: We may want to pre-resolve well-known generic types
if (Map.Entry.class.isAssignableFrom(clz)) {
JavaType[] pts = this.findTypeParameters(clz, Map.Entry.class);
JavaType kt, vt;
if (pts == null || pts.length != 2) {
kt = vt = unknownType();
} else {
kt = pts[0];
vt = pts[1];
}
result = constructSimpleType(clz, Map.Entry.class, new JavaType[] { kt, vt });
} else {
result = new SimpleType(clz);
}
}
_typeCache.put(key, result); // cache object syncs
return result;
}
/**
* Method used by {@link TypeParser} when generics-aware version
* is constructed.
*/
protected JavaType _fromParameterizedClass(Class<?> clz, List<JavaType> paramTypes)
{
if (clz.isArray()) { // ignore generics (should never have any)
return ArrayType.construct(_constructType(clz.getComponentType(), null), null, null);
}
if (clz.isEnum()) { // ditto for enums
return new SimpleType(clz);
}
if (Map.class.isAssignableFrom(clz)) {
// First: if we do have param types, use them
JavaType keyType, contentType;
if (paramTypes.size() > 0) {
keyType = paramTypes.get(0);
contentType = (paramTypes.size() >= 2) ?
paramTypes.get(1) : _unknownType();
return MapType.construct(clz, keyType, contentType);
}
return _mapType(clz);
}
if (Collection.class.isAssignableFrom(clz)) {
if (paramTypes.size() >= 1) {
return CollectionType.construct(clz, paramTypes.get(0));
}
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> _collectionType(clz);
}
if (paramTypes.size() == 0) {
return new SimpleType(clz);
}
// Hmmh. Does this actually occur?
JavaType[] pt = paramTypes.toArray(new JavaType[paramTypes.size()]);
return constructSimpleType(clz, clz, pt);
}
/**
* This method deals with parameterized types, that is,
* first class generic classes.
*/
protected JavaType _fromParamType(ParameterizedType type, TypeBindings context)
{
/* First: what is the actual base type? One odd thing
* is that 'getRawType' returns Type, not Class<?> as
* one might expect. But let's assume it is always of
* type Class: if not, need to add more code to resolve
* it to Class.
*/
Class<?> rawType = (Class<?>) type.getRawType();
Type[] args = type.getActualTypeArguments();
int paramCount = (args == null) ? 0 : args.length;
JavaType[] pt;
if (paramCount == 0) {
pt = NO_TYPES;
} else {
pt = new JavaType[paramCount];
for (int i = 0; i < paramCount; ++i) {
pt[i] = _constructType(args[i], context);
}
}
// Ok: Map or Collection?
if (Map.class.isAssignableFrom(rawType)) {
JavaType subtype = constructSimpleType(rawType, rawType, pt);
JavaType[] mapParams = findTypeParameters(subtype, Map.class);
if (mapParams.length != 2) {
throw new IllegalArgumentException("Could not find 2 type parameters for Map class "+rawType.getName()+" (found "+mapParams.length+")");
}
return MapType.construct(rawType, mapParams[0], mapParams[1]);
}
if (Collection.class.isAssignableFrom(rawType)) {
JavaType subtype = constructSimpleType(rawType, rawType, pt);
JavaType[] collectionParams = findTypeParameters(subtype, Collection.class);
if (collectionParams.length != 1) {
throw new IllegalArgumentException("Could not find 1 type parameter for Collection class "+rawType.getName()+"
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> is need.
/* 29-Jan-2010, tatu: One more problem are recursive types
* (T extends Comparable<T>). Need to add "placeholder"
* for resolution to catch those.
*/
context._addPlaceholder(name);
return _constructType(bounds[0], context);
}
protected JavaType _fromWildcard(WildcardType type, TypeBindings context)
{
/* Similar to challenges with TypeVariable, we may have
* multiple upper bounds. But it is also possible that if
* upper bound defaults to Object, we might want to consider
* lower bounds instead.
*
* For now, we won't try anything more advanced; above is
* just for future reference.
*/
return _constructType(type.getUpperBounds()[0], context);
}
private JavaType _mapType(Class<?> rawClass)
{
JavaType[] typeParams = findTypeParameters(rawClass, Map.class);
// ok to have no types ("raw")
if (typeParams == null) {
return MapType.construct(rawClass, _unknownType(), _unknownType());
}
// but exactly 2 types if any found
if (typeParams.length != 2) {
throw new IllegalArgumentException("Strange Map type "+rawClass.getName()+": can not determine type parameters");
}
return MapType.construct(rawClass, typeParams[0], typeParams[1]);
}
private JavaType _collectionType(Class<?> rawClass)
{
JavaType[] typeParams = findTypeParameters(rawClass, Collection.class);
// ok to have no types ("raw")
if (typeParams == null) {
return CollectionType.construct(rawClass, _unknownType());
}
// but exactly 2 types if any found
if (typeParams.length != 1) {
throw new IllegalArgumentException("Strange Collection type "+rawClass.getName()+": can not determine type parameters");
}
return CollectionType.construct(rawClass, typeParams[0]);
}
protected JavaType _resolveVariableViaSubTypes(HierarchicType leafType, String variableName, TypeBindings bindings)
{
// can't resolve raw types; possible to have as-of-yet-unbound types too:
if (leafType != null &&
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> leafType.isGeneric()) {
TypeVariable<?>[] typeVariables = leafType.getRawClass().getTypeParameters();
for (int i = 0, len = typeVariables.length; i < len; ++i) {
TypeVariable<?> tv = typeVariables[i];
if (variableName.equals(tv.getName())) {
// further resolution needed?
Type type = leafType.asGeneric().getActualTypeArguments()[i];
if (type instanceof TypeVariable<?>) {
return _resolveVariableViaSubTypes(leafType.getSubType(), ((TypeVariable<?>) type).getName(), bindings);
}
// no we're good for the variable (but it may have parameterization of its own)
return _constructType(type, bindings);
}
}
}
return _unknownType();
}
protected JavaType _unknownType() {
return new SimpleType(Object.class);
}
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
/**
* Helper method used to find inheritance (implements, extends) path
* between given types, if one exists (caller generally checks before
* calling this method). Returned type represents given <b>subtype</b>,
* with supertype linkage extending to <b>supertype</b>.
*/
protected HierarchicType _findSuperTypeChain(Class<?> subtype, Class<?> supertype)
{
// If super-type is a class (not interface), bit simpler
if (supertype.isInterface()) {
return _findSuperInterfaceChain(subtype, supertype);
}
return _findSuperClassChain(subtype, supertype);
}
protected HierarchicType _findSuperClassChain(Type currentType, Class<?> target)
{
HierarchicType current = new HierarchicType(currentType);
Class<?> raw = current.getRawClass();
if (raw == target) {
return current;
}
// Otherwise, keep on going down the rat hole...
Type parent = raw.getGenericSuperclass();
if (parent != null) {
HierarchicType sup = _findSuperClassChain(parent, target);
if (sup != null) {
sup.setSubType(current);
current.setSuperType(sup);
return current;
}
}
return null;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> protected HierarchicType _findSuperInterfaceChain(Type currentType, Class<?> target)
{
HierarchicType current = new HierarchicType(currentType);
Class<?> raw = current.getRawClass();
if (raw == target) {
return new HierarchicType(currentType);
}
// Otherwise, keep on going down the rat hole; first implemented interfaces
/* 16-Aug-2011, tatu: Minor optimization based on profiled hot spot; let's
* try caching certain commonly needed cases
*/
if (raw == HashMap.class) {
if (target == Map.class) {
return _hashMapSuperInterfaceChain(current);
}
}
if (raw == ArrayList.class) {
if (target == List.class) {
return _arrayListSuperInterfaceChain(current);
}
}
return _doFindSuperInterfaceChain(current, target);
}
protected HierarchicType _doFindSuperInterfaceChain(HierarchicType current, Class<?> target)
{
Class<?> raw = current.getRawClass();
Type[] parents = raw.getGenericInterfaces();
// as long as there are superclasses
// and unless we have already seen the type (<T extends X<T>>)
if (parents != null) {
for (Type parent : parents) {
HierarchicType sup = _findSuperInterfaceChain(parent, target);
if (sup != null) {
sup.setSubType(current);
current.setSuperType(sup);
return current;
}
}
}
// and then super-class if any
Type parent = raw.getGenericSuperclass();
if (parent != null) {
HierarchicType sup = _findSuperInterfaceChain(parent, target);
if (sup != null) {
sup.setSubType(current);
current.setSuperType(sup);
return current;
}
}
return null;
}
protected synchronized HierarchicType _hashMapSuperInterfaceChain(HierarchicType current)
{
if (_cachedHashMapType == null) {
HierarchicType base = current.deepCloneWithoutSubtype();
_doFindSuperInterfaceChain(base, Map.class);
_cachedHashMapType = base.getSuperType();
}
Hierarchic
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Type t = _cachedHashMapType.deepCloneWithoutSubtype();
current.setSuperType(t);
t.setSubType(current);
return current;
}
protected synchronized HierarchicType _arrayListSuperInterfaceChain(HierarchicType current)
{
if (_cachedArrayListType == null) {
HierarchicType base = current.deepCloneWithoutSubtype();
_doFindSuperInterfaceChain(base, List.class);
_cachedArrayListType = base.getSuperType();
}
HierarchicType t = _cachedArrayListType.deepCloneWithoutSubtype();
current.setSuperType(t);
t.setSubType(current);
return current;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser;
import java.lang.reflect.Type;
import java.util.*;
import com.fasterxml.jackson.annotation.ObjectIdGenerator;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.annotation.ObjectIdResolver;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JsonPOJOBuilder;
import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig;
import com.fasterxml.jackson.databind.deser.impl.*;
import com.fasterxml.jackson.databind.deser.std.ThrowableDeserializer;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ArrayBuilders;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.SimpleBeanPropertyDefinition;
/**
* Concrete deserializer factory class that adds full Bean deserializer
* construction logic using class introspection.
* Note that factories specifically do not implement any form of caching:
* aside from configuration they are stateless; caching is implemented
* by other components.
*<p>
* Instances of this class are fully immutable as all configuration is
* done by using "fluent factories" (methods that construct new factory
* instances with different configuration, instead of modifying instance).
*/
public class BeanDeserializerFactory
extends BasicDeserializerFactory
implements java.io.Serializable // since 2.1
{
private static final long serialVersionUID = 1;
/**
* Signature of <b>Throwable.initCause</b> method.
*/
private final static Class<?>[] INIT_CAUSE_PARAMS = new Class<?>[] { Throwable.class };
private final static Class<?>[] NO_VIEWS = new Class<?>[0];
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* Globally shareable thread-safe instance which has no additional custom deserializers
* registered
*/
public final static BeanDeserializerFactory instance = new BeanDeserializerFactory(
new DeserializerFactoryConfig());
public BeanDeserializerFactory(DeserializerFactoryConfig config) {
super(config);
}
/**
* Method
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> used by module registration functionality, to construct a new bean
* deserializer factory
* with different configuration settings.
*/
@Override
public DeserializerFactory withConfig(DeserializerFactoryConfig config)
{
if (_factoryConfig == config) {
return this;
}
/* 22-Nov-2010, tatu: Handling of subtypes is tricky if we do immutable-with-copy-ctor;
* and we pretty much have to here either choose between losing subtype instance
* when registering additional deserializers, or losing deserializers.
* Instead, let's actually just throw an error if this method is called when subtype
* has not properly overridden this method; this to indicate problem as soon as possible.
*/
if (getClass() != BeanDeserializerFactory.class) {
throw new IllegalStateException("Subtype of BeanDeserializerFactory ("+getClass().getName()
+") has not properly overridden method 'withAdditionalDeserializers': can not instantiate subtype with "
+"additional deserializer definitions");
}
return new BeanDeserializerFactory(config);
}
/*
/**********************************************************
/* DeserializerFactory API implementation
/**********************************************************
*/
/**
* Method that {@link DeserializerCache}s call to create a new
* deserializer for types other than Collections, Maps, arrays and
* enums.
*/
@Override
public JsonDeserializer<Object> createBeanDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// We may also have custom overrides:
JsonDeserializer<Object> custom = _findCustomBeanDeserializer(type, config, beanDesc);
if (custom != null) {
return custom;
}
/* One more thing to check: do we have an exception type
* (Throwable or its sub-classes)? If so, need slightly
* different handling.
*/
if (type.isThrowable()) {
return buildThrowableDeserializer(ctxt, type, beanDesc);
}
/* Or, for abstract types, may have alternate means for resolution
* (defaulting, materialization)
*/
if (type.isAbstract()) {
// [JACKSON-41] (v1.6): Let's make it possible to materialize abstract types.
JavaType concreteType = materializeAbstract
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> builderConfig);
// this may give us more information...
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
builder = mod.updateBuilder(config, builderDesc, builder);
}
}
JsonDeserializer<?> deserializer = builder.buildBuilderBased(
valueType, buildMethodName);
// [JACKSON-440]: may have modifier(s) that wants to modify or replace serializer we just built:
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deserializer = mod.modifyDeserializer(config, builderDesc, deserializer);
}
}
return (JsonDeserializer<Object>) deserializer;
}
protected void addObjectIdReader(DeserializationContext ctxt,
BeanDescription beanDesc, BeanDeserializerBuilder builder)
throws JsonMappingException
{
ObjectIdInfo objectIdInfo = beanDesc.getObjectIdInfo();
if (objectIdInfo == null) {
return;
}
Class<?> implClass = objectIdInfo.getGeneratorType();
JavaType idType;
SettableBeanProperty idProp;
ObjectIdGenerator<?> gen;
ObjectIdResolver resolver = ctxt.objectIdResolverInstance(beanDesc.getClassInfo(), objectIdInfo);
// Just one special case: Property-based generator is trickier
if (implClass == ObjectIdGenerators.PropertyGenerator.class) { // most special one, needs extra work
PropertyName propName = objectIdInfo.getPropertyName();
idProp = builder.findProperty(propName);
if (idProp == null) {
throw new IllegalArgumentException("Invalid Object Id definition for "
+beanDesc.getBeanClass().getName()+": can not find property with name '"+propName+"'");
}
idType = idProp.getType();
gen = new PropertyBasedObjectIdGenerator(objectIdInfo.getScope());
} else {
JavaType type = ctxt.constructType(implClass);
idType = ctxt.getTypeFactory().findTypeParameters(type, ObjectIdGenerator.class)[0];
idProp = null;
gen = ctxt.objectIdGeneratorInstance(beanDesc.getClassInfo(), objectIdInfo);
}
// also: unlike with value deserializers, let's just resolve one we need here
JsonDeserializer<?> deser = ctxt.findRootValueDeserializer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> propertyType = propDef.getSetter().getGenericParameterType(0);
prop = constructSettableProperty(ctxt, beanDesc, propDef, propertyType);
} else if (propDef.hasField()) {
Type propertyType = propDef.getField().getGenericType();
prop = constructSettableProperty(ctxt, beanDesc, propDef, propertyType);
} else if (useGettersAsSetters && propDef.hasGetter()) {
/* As per [JACKSON-88], may also need to consider getters
* for Map/Collection properties; but with lowest precedence
*/
AnnotatedMethod getter = propDef.getGetter();
// should only consider Collections and Maps, for now?
Class<?> rawPropertyType = getter.getRawType();
if (Collection.class.isAssignableFrom(rawPropertyType)
|| Map.class.isAssignableFrom(rawPropertyType)) {
prop = constructSetterlessProperty(ctxt, beanDesc, propDef);
}
}
// 25-Sep-2014, tatu: No point in finding constructor parameters for abstract types
// (since they are never used anyway)
if (isConcrete && propDef.hasConstructorParameter()) {
/* [JACKSON-700] If property is passed via constructor parameter, we must
* handle things in special way. Not sure what is the most optimal way...
* for now, let's just call a (new) method in builder, which does nothing.
*/
// but let's call a method just to allow custom builders to be aware...
final String name = propDef.getName();
CreatorProperty cprop = null;
if (creatorProps != null) {
for (SettableBeanProperty cp : creatorProps) {
if (name.equals(cp.getName())) {
cprop = (CreatorProperty) cp;
break;
}
}
}
if (cprop == null) {
throw ctxt.mappingException("Could not find creator property with name '"
+name+"' (in class "+beanDesc.getBeanClass().getName()+")");
}
if (prop != null) {
cprop = cprop.withFallbackSetter(prop);
}
prop = cprop;
builder.addCreatorProperty(cprop);
continue;
}
if (prop != null) {
Class<?>
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.concurrent.atomic.AtomicReference;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.JsonSerializable;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonschema.JsonSerializableSchema;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.type.TypeFactory;
/**
* Generic handler for types that implement {@link JsonSerializable}.
*<p>
* Note: given that this is used for anything that implements
* interface, can not be checked for direct class equivalence.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class SerializableSerializer
extends StdSerializer<JsonSerializable>
{
public final static SerializableSerializer instance = new SerializableSerializer();
// Ugh. Should NOT need this...
private final static AtomicReference<ObjectMapper> _mapperReference = new AtomicReference<ObjectMapper>();
protected SerializableSerializer() { super(JsonSerializable.class); }
@Override
public void serialize(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
value.serialize(jgen, provider);
}
@Override
public final void serializeWithType(JsonSerializable value, JsonGenerator jgen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException {
value.serializeWithType(jgen, provider, typeSer);
}
@Override
@SuppressWarnings("deprecation")
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
ObjectNode objectNode = createObjectNode();
String schemaType = "any";
String objectProperties = null;
String itemDefinition = null;
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
if (typeHint != null) {
Class<?> rawClass = TypeFactory.rawClass(typeHint);
if (rawClass.isAnnotationPresent(JsonSerializableSchema.class)) {
JsonSerializableSchema schemaInfo = rawClass.getAnnotation(JsonSerializableSchema.class);
schemaType = schemaInfo.schemaType();
if (!JsonSerializableSchema.NO_VALUE.equals(schemaInfo.schemaObjectPropertiesDefinition())) {
objectProperties = schemaInfo.schemaObjectPropertiesDefinition();
}
if (!JsonSerializableSchema.NO_VALUE.equals(schemaInfo.schemaItemDefinition())) {
itemDefinition = schemaInfo.schemaItemDefinition();
}
}
}
/* 19-Mar-2012, tatu: geez, this is butt-ugly abonimation of code...
* really, really should not require back ref to an ObjectMapper.
*/
objectNode.put("type", schemaType);
if (objectProperties != null) {
try {
objectNode.put("properties", _getObjectMapper().readTree(objectProperties));
} catch (IOException e) {
throw new JsonMappingException("Failed to parse @JsonSerializableSchema.schemaObjectPropertiesDefinition value");
}
}
if (itemDefinition != null) {
try {
objectNode.put("items", _getObjectMapper().readTree(itemDefinition));
} catch (IOException e) {
throw new JsonMappingException("Failed to parse @JsonSerializableSchema.schemaItemDefinition value");
}
}
// always optional, no need to specify:
//objectNode.put("required", false);
return objectNode;
}
private final static synchronized ObjectMapper _getObjectMapper()
{
ObjectMapper mapper = _mapperReference.get();
if (mapper == null) {
mapper = new ObjectMapper();
_mapperReference.set(mapper);
}
return mapper;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
visitor.expectAnyFormat(typeHint);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
/**
* Method needed to ensure that {@link ObjectMapper#copy} will work
* properly; specifically, that caches are cleared, but settings
* will otherwise remain identical; and that no sharing of state
* occurs.
*
* @since 2.5
*/
public DefaultSerializerProvider copy() {
throw new IllegalStateException("DefaultSerializerProvider sub-class not overriding copy()");
}
/*
/**********************************************************
/* Extended API: methods that ObjectMapper will call
/**********************************************************
*/
/**
* Overridable method, used to create a non-blueprint instances from the blueprint.
* This is needed to retain state during serialization.
*/
public abstract DefaultSerializerProvider createInstance(SerializationConfig config,
SerializerFactory jsf);
/**
* The method to be called by {@link ObjectMapper} and {@link ObjectWriter}
* for serializing given value, using serializers that
* this provider has access to (via caching and/or creating new serializers
* as need be).
*/
public void serializeValue(JsonGenerator gen, Object value) throws IOException
{
if (value == null) {
_serializeNull(gen);
return;
}
Class<?> cls = value.getClass();
// true, since we do want to cache root-level typed serializers (ditto for null property)
final JsonSerializer<Object> ser = findTypedValueSerializer(cls, true, null);
// Ok: should we wrap result in an additional property ("root name")?
final boolean wrap;
String rootName = _config.getRootName();
if (rootName == null) { // not explicitly specified
// [JACKSON-163]
wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE);
if (wrap) {
PropertyName pname = _rootNames.findRootName(value.getClass(), _config);
gen.writeStartObject();
gen.writeFieldName(pname.simpleAsEncoded(_config));
}
} else if (rootName.length() == 0) {
wrap = false;
} else { // [JACKSON-764]
// empty String means explicitly disabled; non-empty that it is enabled
wrap = true;
gen.writeStartObject();
gen.writeFieldName(rootName);
}
try {
ser.serialize(value, gen, this
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>);
if (wrap) {
gen.writeEndObject();
}
} catch (IOException ioe) { // As per [JACKSON-99], pass IOException and subtypes as-is
throw ioe;
} catch (Exception e) { // but wrap RuntimeExceptions, to get path information
String msg = e.getMessage();
if (msg == null) {
msg = "[no message for "+e.getClass().getName()+"]";
}
throw new JsonMappingException(msg, e);
}
}
/**
* The method to be called by {@link ObjectMapper} and {@link ObjectWriter}
* for serializing given value (assumed to be of specified root type,
* instead of runtime type of value),
* using serializers that
* this provider has access to (via caching and/or creating new serializers
* as need be),
*
* @param rootType Type to use for locating serializer to use, instead of actual
* runtime type. Must be actual type, or one of its super types
*/
public void serializeValue(JsonGenerator gen, Object value, JavaType rootType) throws IOException
{
if (value == null) {
_serializeNull(gen);
return;
}
// Let's ensure types are compatible at this point
if (!rootType.getRawClass().isAssignableFrom(value.getClass())) {
_reportIncompatibleRootType(value, rootType);
}
// root value, not reached via property:
JsonSerializer<Object> ser = findTypedValueSerializer(rootType, true, null);
// Ok: should we wrap result in an additional property ("root name")?
final boolean wrap;
String rootName = _config.getRootName();
if (rootName == null) { // not explicitly specified
// [JACKSON-163]
wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE);
if (wrap) {
gen.writeStartObject();
PropertyName pname = _rootNames.findRootName(value.getClass(), _config);
gen.writeFieldName(pname.simpleAsEncoded(_config));
}
} else if (rootName.length() == 0) {
wrap = false;
} else { // [JACKSON-764]
// empty String means explicitly disabled; non-
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>empty that it is enabled
wrap = true;
gen.writeStartObject();
gen.writeFieldName(rootName);
}
try {
ser.serialize(value, gen, this);
if (wrap) {
gen.writeEndObject();
}
} catch (IOException ioe) { // no wrapping for IO (and derived)
throw ioe;
} catch (Exception e) { // but others do need to be, to get path etc
String msg = e.getMessage();
if (msg == null) {
msg = "[no message for "+e.getClass().getName()+"]";
}
throw new JsonMappingException(msg, e);
}
}
/**
* The method to be called by {@link ObjectWriter}
* for serializing given value (assumed to be of specified root type,
* instead of runtime type of value), when it may know specific
* {@link JsonSerializer} to use.
*
* @param rootType Type to use for locating serializer to use, instead of actual
* runtime type, if no serializer is passed
* @param ser Root Serializer to use, if not null
*
* @since 2.1
*/
public void serializeValue(JsonGenerator gen, Object value, JavaType rootType, JsonSerializer<Object> ser) throws IOException
{
if (value == null) {
_serializeNull(gen);
return;
}
// Let's ensure types are compatible at this point
if ((rootType != null) && !rootType.getRawClass().isAssignableFrom(value.getClass())) {
_reportIncompatibleRootType(value, rootType);
}
// root value, not reached via property:
if (ser == null) {
ser = findTypedValueSerializer(rootType, true, null);
}
// Ok: should we wrap result in an additional property ("root name")?
final boolean wrap;
String rootName = _config.getRootName();
if (rootName == null) { // not explicitly specified
// [JACKSON-163]
wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE);
if (wrap) {
gen.writeStartObject();
PropertyName pname = (rootType == null)
? _rootNames.findRootName(value.getClass(), _config)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> : _rootNames.findRootName(rootType, _config);
gen.writeFieldName(pname.simpleAsEncoded(_config));
}
} else if (rootName.length() == 0) {
wrap = false;
} else { // [JACKSON-764]
// empty String means explicitly disabled; non-empty that it is enabled
wrap = true;
gen.writeStartObject();
gen.writeFieldName(rootName);
}
try {
ser.serialize(value, gen, this);
if (wrap) {
gen.writeEndObject();
}
} catch (IOException ioe) { // no wrapping for IO (and derived)
throw ioe;
} catch (Exception e) { // but others do need to be, to get path etc
String msg = e.getMessage();
if (msg == null) {
msg = "[no message for "+e.getClass().getName()+"]";
}
throw new JsonMappingException(msg, e);
}
}
/**
* Alternate serialization call used for polymorphic types, when {@link TypeSerializer}
* is already known, but not actual value serializer.
*
* @since 2.5
*/
public void serializePolymorphic(JsonGenerator gen, Object value, TypeSerializer typeSer)
throws IOException
{
if (value == null) {
_serializeNull(gen);
return;
}
final Class<?> type = value.getClass();
JsonSerializer<Object> ser = findValueSerializer(type, null);
final boolean wrap;
String rootName = _config.getRootName();
if (rootName == null) {
wrap = _config.isEnabled(SerializationFeature.WRAP_ROOT_VALUE);
if (wrap) {
gen.writeStartObject();
PropertyName pname = _rootNames.findRootName(type, _config);
gen.writeFieldName(pname.simpleAsEncoded(_config));
}
} else if (rootName.length() == 0) {
wrap = false;
} else {
wrap = true;
gen.writeStartObject();
gen.writeFieldName(rootName);
}
try {
ser.serializeWithType(value, gen, this, typeSer);
if (wrap) {
gen.writeEndObject();
}
} catch
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> (IOException ioe) { // no wrapping for IO (and derived)
throw ioe;
} catch (Exception e) { // but others do need to be, to get path etc
String msg = e.getMessage();
if (msg == null) {
msg = "[no message for "+e.getClass().getName()+"]";
}
throw new JsonMappingException(msg, e);
}
}
/**
* Helper method called when root value to serialize is null
*
* @since 2.3
*/
protected void _serializeNull(JsonGenerator gen) throws IOException
{
JsonSerializer<Object> ser = getDefaultNullValueSerializer();
try {
ser.serialize(null, gen, this);
} catch (IOException ioe) { // no wrapping for IO (and derived)
throw ioe;
} catch (Exception e) { // but others do need to be, to get path etc
String msg = e.getMessage();
if (msg == null) {
msg = "[no message for "+e.getClass().getName()+"]";
}
throw new JsonMappingException(msg, e);
}
}
/**
* The method to be called by {@link ObjectMapper} and {@link ObjectWriter}
* to generate <a href="http://json-schema.org/">JSON schema</a> for
* given type.
*
* @param type The type for which to generate schema
*/
@SuppressWarnings("deprecation")
public com.fasterxml.jackson.databind.jsonschema.JsonSchema generateJsonSchema(Class<?> type)
throws JsonMappingException
{
if (type == null) {
throw new IllegalArgumentException("A class must be provided");
}
/* no need for embedded type information for JSON schema generation (all
* type information it needs is accessible via "untyped" serializer)
*/
JsonSerializer<Object> ser = findValueSerializer(type, null);
JsonNode schemaNode = (ser instanceof SchemaAware) ?
((SchemaAware) ser).getSchema(this, null) : com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode();
if (!(schemaNode instanceof ObjectNode)) {
throw new IllegalArgumentException("Class " + type.getName()
+" would not be serialized as a JSON object and therefore has no schema");
}
return new com.fasterxml.jackson.databind.json
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> /**********************************************************
*/
@Override
public JsonSerializer<Object> serializerInstance(Annotated annotated, Object serDef) throws JsonMappingException
{
if (serDef == null) {
return null;
}
JsonSerializer<?> ser;
if (serDef instanceof JsonSerializer) {
ser = (JsonSerializer<?>) serDef;
} else {
/* Alas, there's no way to force return type of "either class
* X or Y" -- need to throw an exception after the fact
*/
if (!(serDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned serializer definition of type "
+serDef.getClass().getName()+"; expected type JsonSerializer or Class<JsonSerializer> instead");
}
Class<?> serClass = (Class<?>)serDef;
// there are some known "no class" markers to consider too:
if (serClass == JsonSerializer.None.class || ClassUtil.isBogusClass(serClass)) {
return null;
}
if (!JsonSerializer.class.isAssignableFrom(serClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "
+serClass.getName()+"; expected Class<JsonSerializer>");
}
HandlerInstantiator hi = _config.getHandlerInstantiator();
ser = (hi == null) ? null : hi.serializerInstance(_config, annotated, serClass);
if (ser == null) {
ser = (JsonSerializer<?>) ClassUtil.createInstance(serClass,
_config.canOverrideAccessModifiers());
}
}
return (JsonSerializer<Object>) _handleResolvable(ser);
}
/*
/**********************************************************
/* Helper classes
/**********************************************************
*/
/**
* Concrete implementation that defines factory method(s),
* defined as final.
*/
public final static class Impl extends DefaultSerializerProvider {
private static final long serialVersionUID = 1L;
public Impl() { super(); }
public Impl(Impl src) { super(src); }
protected Impl(SerializerProvider src, SerializationConfig config,SerializerFactory f) {
super(src, config, f);
}
@Override
public DefaultSerializerProvider copy()
{
if (getClass() != Impl.class) {
return super.copy();
}
return new Impl(this);
}
@Override
public Impl
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.introspect(type);
// Ok, so: can we find T(String) constructor?
Constructor<?> ctor = beanDesc.findSingleArgConstructor(String.class);
if (ctor != null) {
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(ctor);
}
return new StdKeyDeserializer.StringCtorKeyDeserializer(ctor);
}
/* or if not, "static T valueOf(String)" (or equivalent marked
* with @JsonCreator annotation?)
*/
Method m = beanDesc.findFactoryMethod(String.class);
if (m != null){
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(m);
}
return new StdKeyDeserializer.StringFactoryKeyDeserializer(m);
}
// nope, no such luck...
return null;
}
/*
/**********************************************************
/* KeyDeserializers implementation
/**********************************************************
*/
@Override
public KeyDeserializer findKeyDeserializer(JavaType type,
DeserializationConfig config, BeanDescription beanDesc) throws JsonMappingException
{
Class<?> raw = type.getRawClass();
// 23-Apr-2013, tatu: Map primitive types, just in case one was given
if (raw.isPrimitive()) {
raw = ClassUtil.wrapperType(raw);
}
return StdKeyDeserializer.forType(raw);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> // If not, do we have a pattern?
TimeZone tz = format.getTimeZone();
if (format.hasPattern()) {
String pattern = format.getPattern();
final Locale loc = format.hasLocale() ? format.getLocale() : prov.getLocale();
SimpleDateFormat df = new SimpleDateFormat(pattern, loc);
if (tz == null) {
tz = prov.getTimeZone();
}
df.setTimeZone(tz);
return withFormat(asNumber, df);
}
// If not, do we at least have a custom timezone?
if (tz != null) {
DateFormat df = prov.getConfig().getDateFormat();
// one shortcut: with our custom format, can simplify handling a bit
if (df.getClass() == StdDateFormat.class) {
final Locale loc = format.hasLocale() ? format.getLocale() : prov.getLocale();
df = StdDateFormat.getISO8601Format(tz, loc);
} else {
// otherwise need to clone, re-set timezone:
df = (DateFormat) df.clone();
df.setTimeZone(tz);
}
return withFormat(asNumber, df);
}
}
}
return this;
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public boolean isEmpty(T value) {
// let's assume "null date" (timestamp 0) qualifies for empty
return (value == null) || (_timestamp(value) == 0L);
}
protected abstract long _timestamp(T value);
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
//todo: (ryan) add a format for the date in the schema?
return createSchemaNode(_asTimestamp(provider) ? "number" : "string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
_acceptJsonFormatVisitor(visitor, typeHint, _asTimestamp(visitor.getProvider()));
}
/*
/**********************************************************
/* Actual serialization
/**********************************************************
*/
@Override
public abstract void serialize(T value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException;
/*
/**********************************************************
/* Helper methods
/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.text.DateFormat;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
/**
* For efficiency, we will serialize Dates as longs, instead of
* potentially more readable Strings.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class DateSerializer
extends DateTimeSerializerBase<Date>
{
/**
* Default instance that is used when no contextual configuration
* is needed.
*/
public static final DateSerializer instance = new DateSerializer();
public DateSerializer() {
this(null, null);
}
public DateSerializer(Boolean useTimestamp, DateFormat customFormat) {
super(Date.class, useTimestamp, customFormat);
}
@Override
public DateSerializer withFormat(Boolean timestamp, DateFormat customFormat) {
return new DateSerializer(timestamp, customFormat);
}
@Override
protected long _timestamp(Date value) {
return (value == null) ? 0L : value.getTime();
}
@Override
public void serialize(Date value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
if (_asTimestamp(provider)) {
jgen.writeNumber(_timestamp(value));
} else if (_customFormat != null) {
// 21-Feb-2011, tatu: not optimal, but better than alternatives:
synchronized (_customFormat) {
jgen.writeString(_customFormat.format(value));
}
} else {
provider.defaultSerializeDateValue(value, jgen);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
@Override
public int getParameterCount() {
return getRawParameterTypes().length;
}
public String getFullName() {
return getDeclaringClass().getName() + "#" + getName() + "("
+getParameterCount()+" params)";
}
public Class<?>[] getRawParameterTypes()
{
if (_paramClasses == null) {
_paramClasses = _method.getParameterTypes();
}
return _paramClasses;
}
public Type[] getGenericParameterTypes() {
return _method.getGenericParameterTypes();
}
@Override
public Class<?> getRawParameterType(int index)
{
Class<?>[] types = getRawParameterTypes();
return (index >= types.length) ? null : types[index];
}
@Override
public Type getGenericParameterType(int index)
{
Type[] types = _method.getGenericParameterTypes();
return (index >= types.length) ? null : types[index];
}
public Class<?> getRawReturnType() {
return _method.getReturnType();
}
public Type getGenericReturnType() {
return _method.getGenericReturnType();
}
/**
* Helper method that can be used to check whether method returns
* a value or not; if return type declared as <code>void</code>, returns
* false, otherwise true
*
* @since 2.4
*/
public boolean hasReturnType() {
Class<?> rt = getRawReturnType();
return (rt != Void.TYPE && rt != Void.class);
}
/*
/********************************************************
/* Other
/********************************************************
*/
@Override
public String toString() {
return "[method "+getFullName()+"]";
}
@Override
public int hashCode() {
return _method.getName().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
return ((AnnotatedMethod) o)._method == _method;
}
/*
/**********************************************************
/* JDK serialization handling
/**********************************************************
*/
Object writeReplace() {
return new AnnotatedMethod(new Serialization(_method));
}
Object readResolve() {
Class<?> clazz = _serialization.clazz;
try {
Method m = clazz.getDeclaredMethod(_serialization.name
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
/**
* Standard deserializer for {@link EnumSet}s.
* <p>
* Note: casting within this class is all messed up -- just could not figure out a way
* to properly deal with recursive definition of "EnumSet<K extends Enum<K>, V>
*/
@SuppressWarnings("rawtypes")
public class EnumSetDeserializer
extends StdDeserializer<EnumSet<?>>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L; // since 2.5
protected final JavaType _enumType;
protected final Class<Enum> _enumClass;
protected JsonDeserializer<Enum<?>> _enumDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
@SuppressWarnings("unchecked" )
public EnumSetDeserializer(JavaType enumType, JsonDeserializer<?> deser)
{
super(EnumSet.class);
_enumType = enumType;
_enumClass = (Class<Enum>) enumType.getRawClass();
_enumDeserializer = (JsonDeserializer<Enum<?>>) deser;
}
public EnumSetDeserializer withDeserializer(JsonDeserializer<?> deser) {
if (_enumDeserializer == deser) {
return this;
}
return new EnumSetDeserializer(_enumType, deser);
}
/**
* Because of costs associated with constructing Enum resolvers,
* let's cache instances by default.
*/
@Override
public boolean isCachable() {
// One caveat: content deserializer should prevent caching
if (_enumType.getValueHandler() != null) {
return false;
}
return true;
}
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _enumDeserializer;
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(_enumType, property);
} else { // if directly assigned, probably not yet contextual, so:
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> deser = ctxt.handleSecondaryContextualization(deser, property, _enumType);
}
return withDeserializer(deser);
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked")
@Override
public EnumSet<?> deserialize(JsonParser jp, DeserializationContext ctxt)
throws IOException, JsonProcessingException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!jp.isExpectedStartArrayToken()) {
throw ctxt.mappingException(EnumSet.class);
}
EnumSet result = constructSet();
JsonToken t;
try {
while ((t = jp.nextToken()) != JsonToken.END_ARRAY) {
/* What to do with nulls? Fail or ignore? Fail, for now
* (note: would fail if we passed it to EnumDeserializer, too,
* but in general nulls should never be passed to non-container
* deserializers)
*/
if (t == JsonToken.VALUE_NULL) {
throw ctxt.mappingException(_enumClass);
}
Enum<?> value = _enumDeserializer.deserialize(jp, ctxt);
/* 24-Mar-2012, tatu: As per [JACKSON-810], may actually get nulls;
* but EnumSets don't allow nulls so need to skip.
*/
if (value != null) {
result.add(value);
}
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, result, result.size());
}
return result;
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException, JsonProcessingException
{
return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
}
@SuppressWarnings("unchecked")
private EnumSet constructSet()
{
// superbly ugly... but apparently necessary
return EnumSet.noneOf(_enumClass);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> Default value indicates that
* property should only be written if specified attribute has a non-null
* value.
*/
public JsonInclude.Include include() default JsonInclude.Include.NON_NULL;
/**
* Metadata about property, similar to
* {@link com.fasterxml.jackson.annotation.JsonProperty#required()}.
*/
public boolean required() default false;
}
/**
* Definition of a single general virtual property.
*/
public @interface Prop
{
/**
* Actual implementation class (a subtype of {@link VirtualBeanPropertyWriter})
* of the property to instantiate (using the no-argument default constructor).
*/
public Class<? extends VirtualBeanPropertyWriter> value();
/**
* Name of the property to possibly use for serializing (although implementation
* may choose to not use this information).
*/
public String name() default "";
/**
* Optional namespace to use along with {@link #name};
* only relevant for data formats that use namespaces (like XML).
*/
public String namespace() default "";
/**
* When to include value of the property. Default value indicates that
* property should only be written if specified attribute has a non-null
* value. As with other properties, actual property implementation may or may
* not choose to use this inclusion information.
*/
public JsonInclude.Include include() default JsonInclude.Include.NON_NULL;
/**
* Metadata about property, similar to
* {@link com.fasterxml.jackson.annotation.JsonProperty#required()}.
*/
public boolean required() default false;
/**
* Nominal type of the property. Passed as type information for related
* virtual objects, and may (or may not be) used by implementation
* for choosing serializer to use.
*/
public Class<?> type() default Object.class;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
/**
* Serializer used for primitive boolean, as well as java.util.Boolean
* wrapper type.
*<p>
* Since this is one of "native" types, no type information is ever
* included on serialization (unlike for most scalar types as of 1.5)
*/
@JacksonStdImpl
public final class BooleanSerializer
extends NonTypedScalarSerializerBase<Boolean>
{
private static final long serialVersionUID = 1L;
/**
* Whether type serialized is primitive (boolean) or wrapper
* (java.lang.Boolean); if true, former, if false, latter.
*/
protected final boolean _forPrimitive;
public BooleanSerializer(boolean forPrimitive) {
super(Boolean.class);
_forPrimitive = forPrimitive;
}
@Override
public void serialize(Boolean value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeBoolean(value.booleanValue());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("boolean", !_forPrimitive);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
if (visitor != null) {
visitor.expectBooleanFormat(typeHint);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>) {
// let's invalidate the read-only copy, too, to get it updated
_readOnlyMap = null;
}
/* Finally: some serializers want to do post-processing, after
* getting registered (to handle cyclic deps).
*/
/* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done
* in synchronized manner; this because while we do need to register
* instance first, we also must keep lock until resolution is complete
*/
if (ser instanceof ResolvableSerializer) {
((ResolvableSerializer) ser).resolve(provider);
}
}
}
public void addAndResolveNonTypedSerializer(JavaType type, JsonSerializer<Object> ser,
SerializerProvider provider)
throws JsonMappingException
{
synchronized (this) {
if (_sharedMap.put(new TypeKey(type, false), ser) == null) {
// let's invalidate the read-only copy, too, to get it updated
_readOnlyMap = null;
}
/* Finally: some serializers want to do post-processing, after
* getting registered (to handle cyclic deps).
*/
/* 14-May-2011, tatu: As per [JACKSON-570], resolving needs to be done
* in synchronized manner; this because while we do need to register
* instance first, we also must keep lock until resolution is complete
*/
if (ser instanceof ResolvableSerializer) {
((ResolvableSerializer) ser).resolve(provider);
}
}
}
/**
* Method called by StdSerializerProvider#flushCachedSerializers() to
* clear all cached serializers
*/
public synchronized void flush() {
_sharedMap.clear();
}
/*
/**************************************************************
/* Helper class(es)
/**************************************************************
*/
/**
* Key that offers two "modes"; one with raw class, as used for
* cases were raw class type is available (for example, when using
* runtime type); and one with full generics-including.
*/
public final static class TypeKey
{
protected int _hashCode;
protected Class<?> _class;
protected JavaType _type;
/**
* Indicator of whether serializer stored has a type serializer
* wrapper around it
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> or not; if not, it is "untyped" serializer;
* if it has, it is "typed"
*/
protected boolean _isTyped;
public TypeKey(Class<?> key, boolean typed) {
_class = key;
_type = null;
_isTyped = typed;
_hashCode = hash(key, typed);
}
public TypeKey(JavaType key, boolean typed) {
_type = key;
_class = null;
_isTyped = typed;
_hashCode = hash(key, typed);
}
private final static int hash(Class<?> cls, boolean typed) {
int hash = cls.getName().hashCode();
if (typed) {
++hash;
}
return hash;
}
private final static int hash(JavaType type, boolean typed) {
int hash = type.hashCode() - 1;
if (typed) {
--hash;
}
return hash;
}
public void resetTyped(Class<?> cls) {
_type = null;
_class = cls;
_isTyped = true;
_hashCode = hash(cls, true);
}
public void resetUntyped(Class<?> cls) {
_type = null;
_class = cls;
_isTyped = false;
_hashCode = hash(cls, false);
}
public void resetTyped(JavaType type) {
_type = type;
_class = null;
_isTyped = true;
_hashCode = hash(type, true);
}
public void resetUntyped(JavaType type) {
_type = type;
_class = null;
_isTyped = false;
_hashCode = hash(type, false);
}
@Override public final int hashCode() { return _hashCode; }
@Override public final String toString() {
if (_class != null) {
return "{class: "+_class.getName()+", typed? "+_isTyped+"}";
}
return "{type: "+_type+", typed? "+_isTyped+"}";
}
// note: we assume key is never used for anything other than as map key, so:
@Override public final boolean equals(Object o)
{
if (o == null) return false;
if (o == this) return true;
if
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> (o.getClass() != getClass()) {
return false;
}
TypeKey other = (TypeKey) o;
if (other._isTyped == _isTyped) {
if (_class != null) {
return other._class == _class;
}
return _type.equals(other._type);
}
return false;
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>additional == null) {
throw new IllegalArgumentException("Can not pass null Serializers");
}
Serializers[] all = ArrayBuilders.insertInListNoDup(_additionalKeySerializers, additional);
return new SerializerFactoryConfig(_additionalSerializers, all, _modifiers);
}
public SerializerFactoryConfig withSerializerModifier(BeanSerializerModifier modifier)
{
if (modifier == null) {
throw new IllegalArgumentException("Can not pass null modifier");
}
BeanSerializerModifier[] modifiers = ArrayBuilders.insertInListNoDup(_modifiers, modifier);
return new SerializerFactoryConfig(_additionalSerializers, _additionalKeySerializers, modifiers);
}
public boolean hasSerializers() { return _additionalSerializers.length > 0; }
public boolean hasKeySerializers() { return _additionalKeySerializers.length > 0; }
public boolean hasSerializerModifiers() { return _modifiers.length > 0; }
public Iterable<Serializers> serializers() { return new ArrayIterator<Serializers>(_additionalSerializers); }
public Iterable<Serializers> keySerializers() { return new ArrayIterator<Serializers>(_additionalKeySerializers); }
public Iterable<BeanSerializerModifier> serializerModifiers() { return new ArrayIterator<BeanSerializerModifier>(_modifiers); }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> not instances
*/
protected final static HashMap<String, Class<? extends JsonSerializer<?>>> _concreteLazy =
new HashMap<String, Class<? extends JsonSerializer<?>>>();
static {
/* String and string-like types (note: date types explicitly
* not included -- can use either textual or numeric serialization)
*/
_concrete.put(String.class.getName(), new StringSerializer());
final ToStringSerializer sls = ToStringSerializer.instance;
_concrete.put(StringBuffer.class.getName(), sls);
_concrete.put(StringBuilder.class.getName(), sls);
_concrete.put(Character.class.getName(), sls);
_concrete.put(Character.TYPE.getName(), sls);
// Primitives/wrappers for primitives (primitives needed for Beans)
NumberSerializers.addAll(_concrete);
_concrete.put(Boolean.TYPE.getName(), new BooleanSerializer(true));
_concrete.put(Boolean.class.getName(), new BooleanSerializer(false));
// Other numbers, more complicated
_concrete.put(BigInteger.class.getName(), new NumberSerializer(BigInteger.class));
_concrete.put(BigDecimal.class.getName(),new NumberSerializer(BigDecimal.class));
// Other discrete non-container types:
// First, Date/Time zoo:
_concrete.put(Calendar.class.getName(), CalendarSerializer.instance);
DateSerializer dateSer = DateSerializer.instance;
_concrete.put(java.util.Date.class.getName(), dateSer);
// note: timestamps are very similar to java.util.Date, thus serialized as such
_concrete.put(java.sql.Timestamp.class.getName(), dateSer);
// leave some of less commonly used ones as lazy, no point in proactive construction
_concreteLazy.put(java.sql.Date.class.getName(), SqlDateSerializer.class);
_concreteLazy.put(java.sql.Time.class.getName(), SqlTimeSerializer.class);
// And then other standard non-structured JDK types
for (Map.Entry<Class<?>,Object> en : StdJdkSerializers.all()) {
Object value = en.getValue();
if (value instanceof JsonSerializer<?>) {
_concrete.put(en.getKey().getName(), (JsonSerializer<?>) value);
} else if (value instanceof Class<?
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>>) {
@SuppressWarnings("unchecked")
Class<? extends JsonSerializer<?>> cls = (Class<? extends JsonSerializer<?>>) value;
_concreteLazy.put(en.getKey().getName(), cls);
} else { // should never happen, but:
throw new IllegalStateException("Internal error: unrecognized value of type "+en.getClass().getName());
}
}
// Jackson-specific type(s)
// (Q: can this ever be sub-classed?)
_concreteLazy.put(TokenBuffer.class.getName(), TokenBufferSerializer.class);
}
/*
/**********************************************************
/* Configuration
/**********************************************************
*/
/**
* Configuration settings for this factory; immutable instance (just like this
* factory), new version created via copy-constructor (fluent-style)
*/
protected final SerializerFactoryConfig _factoryConfig;
/*
/**********************************************************
/* Life cycle
/**********************************************************
*/
/**
* We will provide default constructor to allow sub-classing,
* but make it protected so that no non-singleton instances of
* the class will be instantiated.
*/
protected BasicSerializerFactory(SerializerFactoryConfig config) {
_factoryConfig = (config == null) ? new SerializerFactoryConfig() : config;
}
/**
* Method for getting current {@link SerializerFactoryConfig}.
*<p>
* Note that since instances are immutable, you can NOT change settings
* by accessing an instance and calling methods: this will simply create
* new instance of config object.
*/
public SerializerFactoryConfig getFactoryConfig() {
return _factoryConfig;
}
/**
* Method used for creating a new instance of this factory, but with different
* configuration. Reason for specifying factory method (instead of plain constructor)
* is to allow proper sub-classing of factories.
*<p>
* Note that custom sub-classes generally <b>must override</b> implementation
* of this method, as it usually requires instantiating a new instance of
* factory type. Check out javadocs for
* {@link com.fasterxml.jackson.databind.ser.BeanSerializerFactory} for more details.
*/
public abstract SerializerFactory withConfig(SerializerFactoryConfig config);
/**
* Convenience method for creating a new factory instance with an additional
* serializer provider.
*/
@Override
public final SerializerFactory withAdditionalSerial
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>izers(Serializers additional) {
return withConfig(_factoryConfig.withAdditionalSerializers(additional));
}
/**
* Convenience method for creating a new factory instance with an additional
* key serializer provider.
*/
@Override
public final SerializerFactory withAdditionalKeySerializers(Serializers additional) {
return withConfig(_factoryConfig.withAdditionalKeySerializers(additional));
}
/**
* Convenience method for creating a new factory instance with additional bean
* serializer modifier.
*/
@Override
public final SerializerFactory withSerializerModifier(BeanSerializerModifier modifier) {
return withConfig(_factoryConfig.withSerializerModifier(modifier));
}
/*
/**********************************************************
/* SerializerFactory impl
/**********************************************************
*/
// Implemented by sub-classes
@Override
public abstract JsonSerializer<Object> createSerializer(SerializerProvider prov,
JavaType type)
throws JsonMappingException;
@Override
@SuppressWarnings("unchecked")
public JsonSerializer<Object> createKeySerializer(SerializationConfig config,
JavaType keyType, JsonSerializer<Object> defaultImpl)
{
// We should not need any member method info; at most class annotations for Map type
// ... at least, not here.
BeanDescription beanDesc = config.introspectClassAnnotations(keyType.getRawClass());
JsonSerializer<?> ser = null;
// Minor optimization: to avoid constructing beanDesc, bail out if none registered
if (_factoryConfig.hasKeySerializers()) {
// Only thing we have here are module-provided key serializers:
for (Serializers serializers : _factoryConfig.keySerializers()) {
ser = serializers.findSerializer(config, keyType, beanDesc);
if (ser != null) {
break;
}
}
}
if (ser == null) {
ser = defaultImpl;
if (ser == null) {
ser = StdKeySerializers.getStdKeySerializer(config, keyType.getRawClass(), false);
// As per [databind#47], also need to support @JsonValue
if (ser == null) {
beanDesc = config.introspect(keyType);
AnnotatedMethod am = beanDesc.findJsonValueMethod();
if (am != null) {
final Class<?> rawType = am.getRawReturnType();
JsonSerializer<?> delegate = StdKeySerializers.getStdKeySerializer(config,
rawType,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> {
Class<?> raw = type.getRawClass();
String clsName = raw.getName();
JsonSerializer<?> ser = _concrete.get(clsName);
if (ser == null) {
Class<? extends JsonSerializer<?>> serClass = _concreteLazy.get(clsName);
if (serClass != null) {
try {
return serClass.newInstance();
} catch (Exception e) {
throw new IllegalStateException("Failed to instantiate standard serializer (of type "+serClass.getName()+"): "
+e.getMessage(), e);
}
}
}
return ser;
}
/**
* Method called to see if one of primary per-class annotations
* (or related, like implementing of {@link JsonSerializable})
* determines the serializer to use.
*<p>
* Currently handles things like:
*<ul>
* <li>If type implements {@link JsonSerializable}, use that
* </li>
* <li>If type has {@link com.fasterxml.jackson.annotation.JsonValue} annotation (or equivalent), build serializer
* based on that property
* </li>
*</ul>
*
* @since 2.0
*/
protected final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider prov,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
Class<?> raw = type.getRawClass();
// First: JsonSerializable?
if (JsonSerializable.class.isAssignableFrom(raw)) {
return SerializableSerializer.instance;
}
// Second: @JsonValue for any type
AnnotatedMethod valueMethod = beanDesc.findJsonValueMethod();
if (valueMethod != null) {
Method m = valueMethod.getAnnotated();
if (prov.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(m);
}
JsonSerializer<Object> ser = findSerializerFromAnnotation(prov, valueMethod);
return new JsonValueSerializer(m, ser);
}
// No well-known annotations...
return null;
}
/**
* Method for checking if we can determine serializer to use based on set of
* known primary types, checking for set of known base types (exact matches
* having been compared against with <code>findSerializerByLookup</code>).
* This does not include "secondary" interfaces, but
* mostly concrete or abstract base
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> classes.
*/
protected final JsonSerializer<?> findSerializerByPrimaryType(SerializerProvider prov,
JavaType type, BeanDescription beanDesc,
boolean staticTyping)
throws JsonMappingException
{
Class<?> raw = type.getRawClass();
// Then check for optional/external serializers [JACKSON-386]
JsonSerializer<?> ser = findOptionalStdSerializer(prov, type, beanDesc, staticTyping);
if (ser != null) {
return ser;
}
if (Calendar.class.isAssignableFrom(raw)) {
return CalendarSerializer.instance;
}
if (java.util.Date.class.isAssignableFrom(raw)) {
return DateSerializer.instance;
}
if (Map.Entry.class.isAssignableFrom(raw)) {
JavaType kt, vt;
JavaType[] params = prov.getTypeFactory().findTypeParameters(type, Map.Entry.class);
if (params == null || params.length != 2) { // assume that if we don't get 2, they are wrong...
kt = vt = TypeFactory.unknownType();
} else {
kt = params[0];
vt = params[1];
}
return buildMapEntrySerializer(prov.getConfig(), type, beanDesc, staticTyping, kt, vt);
}
if (ByteBuffer.class.isAssignableFrom(raw)) {
return new ByteBufferSerializer();
}
if (InetAddress.class.isAssignableFrom(raw)) {
return new InetAddressSerializer();
}
if (InetSocketAddress.class.isAssignableFrom(raw)) {
return new InetSocketAddressSerializer();
}
if (TimeZone.class.isAssignableFrom(raw)) {
return new TimeZoneSerializer();
}
if (java.nio.charset.Charset.class.isAssignableFrom(raw)) {
return ToStringSerializer.instance;
}
if (Number.class.isAssignableFrom(raw)) {
// 21-May-2014, tatu: Couple of alternatives actually
JsonFormat.Value format = beanDesc.findExpectedFormat(null);
if (format != null) {
switch (format.getShape()) {
case STRING:
return ToStringSerializer.instance;
case OBJECT: // need to bail out to let it be serialized as POJO
case ARRAY: // or, I guess ARRAY; otherwise no point in speculating
return null;
default:
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
}
return NumberSerializer.instance;
}
if (Enum.class.isAssignableFrom(raw)) {
return buildEnumSerializer(prov.getConfig(), type, beanDesc);
}
return null;
}
/**
* Overridable method called after checking all other types.
*
* @since 2.2
*/
protected JsonSerializer<?> findOptionalStdSerializer(SerializerProvider prov,
JavaType type, BeanDescription beanDesc, boolean staticTyping)
throws JsonMappingException
{
return OptionalHandlerFactory.instance.findSerializer(prov.getConfig(), type, beanDesc);
}
/**
* Reflection-based serialized find method, which checks if
* given class implements one of recognized "add-on" interfaces.
* Add-on here means a role that is usually or can be a secondary
* trait: for example,
* bean classes may implement {@link Iterable}, but their main
* function is usually something else. The reason for
*/
protected final JsonSerializer<?> findSerializerByAddonType(SerializationConfig config,
JavaType javaType, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException
{
Class<?> type = javaType.getRawClass();
if (Iterator.class.isAssignableFrom(type)) {
JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterator.class);
JavaType vt = (params == null || params.length != 1) ?
TypeFactory.unknownType() : params[0];
return buildIteratorSerializer(config, javaType, beanDesc, staticTyping, vt);
}
if (Iterable.class.isAssignableFrom(type)) {
JavaType[] params = config.getTypeFactory().findTypeParameters(javaType, Iterable.class);
JavaType vt = (params == null || params.length != 1) ?
TypeFactory.unknownType() : params[0];
return buildIterableSerializer(config, javaType, beanDesc, staticTyping, vt);
}
if (CharSequence.class.isAssignableFrom(type)) {
return ToStringSerializer.instance;
}
return null;
}
/**
* Helper method called to check if a class or method
* has an annotation
* (@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using)
* that tells the class to use for serialization.
* Returns null if
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.useStaticType()) {
if (!type.isContainerType() || type.getContentType().getRawClass() != Object.class) {
staticTyping = true;
}
}
// Let's see what we can learn about element/content/value type, type serializer for it:
JavaType elementType = type.getContentType();
TypeSerializer elementTypeSerializer = createTypeSerializer(config,
elementType);
// if elements have type serializer, can not force static typing:
if (elementTypeSerializer != null) {
staticTyping = false;
}
JsonSerializer<Object> elementValueSerializer = _findContentSerializer(prov,
beanDesc.getClassInfo());
if (type.isMapLikeType()) { // implements java.util.Map
MapLikeType mlt = (MapLikeType) type;
/* 29-Sep-2012, tatu: This is actually too early to (try to) find
* key serializer from property annotations, and can lead to caching
* issues (see [Issue#75]). Instead, must be done from 'createContextual()' call.
* But we do need to check class annotations.
*/
JsonSerializer<Object> keySerializer = _findKeySerializer(prov, beanDesc.getClassInfo());
if (mlt.isTrueMapType()) {
return buildMapSerializer(config, (MapType) mlt, beanDesc, staticTyping,
keySerializer, elementTypeSerializer, elementValueSerializer);
}
// Only custom serializers may be available:
for (Serializers serializers : customSerializers()) {
MapLikeType mlType = (MapLikeType) type;
JsonSerializer<?> ser = serializers.findMapLikeSerializer(config,
mlType, beanDesc, keySerializer, elementTypeSerializer, elementValueSerializer);
if (ser != null) {
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifyMapLikeSerializer(config, mlType, beanDesc, ser);
}
}
return ser;
}
}
return null;
}
if (type.isCollectionLikeType()) {
CollectionLikeType clt = (CollectionLikeType) type;
if (clt.isTrueCollection
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Type()) {
return buildCollectionSerializer(config, (CollectionType) clt, beanDesc, staticTyping,
elementTypeSerializer, elementValueSerializer);
}
CollectionLikeType clType = (CollectionLikeType) type;
// Only custom variants for this:
for (Serializers serializers : customSerializers()) {
JsonSerializer<?> ser = serializers.findCollectionLikeSerializer(config,
clType, beanDesc, elementTypeSerializer, elementValueSerializer);
if (ser != null) {
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifyCollectionLikeSerializer(config, clType, beanDesc, ser);
}
}
return ser;
}
}
// fall through either way (whether shape dictates serialization as POJO or not)
return null;
}
if (type.isArrayType()) {
return buildArraySerializer(config, (ArrayType) type, beanDesc, staticTyping,
elementTypeSerializer, elementValueSerializer);
}
return null;
}
/**
* Helper method that handles configuration details when constructing serializers for
* {@link java.util.List} types that support efficient by-index access
*
* @since 2.1
*/
protected JsonSerializer<?> buildCollectionSerializer(SerializationConfig config,
CollectionType type, BeanDescription beanDesc, boolean staticTyping,
TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
throws JsonMappingException
{
JsonSerializer<?> ser = null;
// Module-provided custom collection serializers?
for (Serializers serializers : customSerializers()) {
ser = serializers.findCollectionSerializer(config,
type, beanDesc, elementTypeSerializer, elementValueSerializer);
if (ser != null) {
break;
}
}
if (ser == null) {
// We may also want to use serialize Collections "as beans", if (and only if)
// this is specified with `@JsonFormat(shape=Object)`
JsonFormat.Value format = beanDesc.findExpectedFormat(null);
if (format != null && format.getShape() == JsonFormat.Shape.OBJECT) {
return null;
}
Class<?> raw = type.getRawClass();
if (Enum
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Set.class.isAssignableFrom(raw)) {
// this may or may not be available (Class doesn't; type of field/method does)
JavaType enumType = type.getContentType();
// and even if nominally there is something, only use if it really is enum
if (!enumType.isEnumType()) {
enumType = null;
}
ser = buildEnumSetSerializer(enumType);
} else {
Class<?> elementRaw = type.getContentType().getRawClass();
if (isIndexedList(raw)) {
if (elementRaw == String.class) {
// [JACKSON-829] Must NOT use if we have custom serializer
if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(elementValueSerializer)) {
ser = IndexedStringListSerializer.instance;
}
} else {
ser = buildIndexedListSerializer(type.getContentType(), staticTyping,
elementTypeSerializer, elementValueSerializer);
}
} else if (elementRaw == String.class) {
// [JACKSON-829] Must NOT use if we have custom serializer
if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(elementValueSerializer)) {
ser = StringCollectionSerializer.instance;
}
}
if (ser == null) {
ser = buildCollectionSerializer(type.getContentType(), staticTyping,
elementTypeSerializer, elementValueSerializer);
}
}
}
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifyCollectionSerializer(config, type, beanDesc, ser);
}
}
return ser;
}
/*
/**********************************************************
/* Factory methods, for Collections
/**********************************************************
*/
protected boolean isIndexedList(Class<?> cls)
{
return RandomAccess.class.isAssignableFrom(cls);
}
public ContainerSerializer<?> buildIndexedListSerializer(JavaType elemType,
boolean staticTyping, TypeSerializer vts, JsonSerializer<Object> valueSerializer) {
return new IndexedListSerializer(elemType, staticTyping, vts, null, valueSerializer);
}
public ContainerSerializer<?> buildCollectionSerializer(JavaType elemType,
boolean staticTyping,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> TypeSerializer vts, JsonSerializer<Object> valueSerializer) {
return new CollectionSerializer(elemType, staticTyping, vts, null, valueSerializer);
}
public JsonSerializer<?> buildEnumSetSerializer(JavaType enumType) {
return new EnumSetSerializer(enumType, null);
}
/*
/**********************************************************
/* Factory methods, for Maps
/**********************************************************
*/
/**
* Helper method that handles configuration details when constructing serializers for
* {@link java.util.Map} types.
*/
protected JsonSerializer<?> buildMapSerializer(SerializationConfig config,
MapType type, BeanDescription beanDesc,
boolean staticTyping, JsonSerializer<Object> keySerializer,
TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
throws JsonMappingException
{
JsonSerializer<?> ser = null;
for (Serializers serializers : customSerializers()) {
ser = serializers.findMapSerializer(config, type, beanDesc,
keySerializer, elementTypeSerializer, elementValueSerializer);
if (ser != null) { break; }
}
if (ser == null) {
// 08-Nov-2014, tatu: As per [databind#601], better just use default Map serializer
/*
if (EnumMap.class.isAssignableFrom(type.getRawClass())
&& ((keySerializer == null) || ClassUtil.isJacksonStdImpl(keySerializer))) {
JavaType keyType = type.getKeyType();
// Need to find key enum values...
EnumValues enums = null;
if (keyType.isEnumType()) { // non-enum if we got it as type erased class (from instance)
@SuppressWarnings("unchecked")
Class<Enum<?>> enumClass = (Class<Enum<?>>) keyType.getRawClass();
enums = EnumValues.construct(config, enumClass);
}
ser = new EnumMapSerializer(type.getContentType(), staticTyping, enums,
elementTypeSerializer, elementValueSerializer);
} else {
*/
Object filterId = findFilterId(config, beanDesc);
MapSerializer mapSer = MapSerializer.construct(config.getAnnotationIntrospector().findPropertiesToIgnore(beanDesc.getClassInfo()),
type, staticTyping, elementTypeSerializer,
keySerializer, elementValueSerializer, filterId);
Object suppressableValue = findSuppressableContentValue
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(config,
type.getContentType(), beanDesc);
if (suppressableValue != null) {
mapSer = mapSer.withContentInclusion(suppressableValue);
}
ser = mapSer;
}
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifyMapSerializer(config, type, beanDesc, ser);
}
}
return ser;
}
/**
* @since 2.5
*/
protected Object findSuppressableContentValue(SerializationConfig config,
JavaType contentType, BeanDescription beanDesc)
throws JsonMappingException
{
JsonInclude.Include incl = beanDesc.findSerializationInclusionForContent(null);
if (incl != null) {
switch (incl) {
case NON_DEFAULT:
// 19-Oct-2014, tatu: Not sure what this'd mean; so take it to mean "NON_EMPTY"...
incl = JsonInclude.Include.NON_EMPTY;
break;
default:
// all other modes actually good as is, unless we'll find better ways
break;
}
return incl;
}
return null;
}
/*
/**********************************************************
/* Factory methods, for Arrays
/**********************************************************
*/
/**
* Helper method that handles configuration details when constructing serializers for
* <code>Object[]</code> (and subtypes, except for String).
*/
protected JsonSerializer<?> buildArraySerializer(SerializationConfig config,
ArrayType type, BeanDescription beanDesc,
boolean staticTyping,
TypeSerializer elementTypeSerializer, JsonSerializer<Object> elementValueSerializer)
throws JsonMappingException
{
JsonSerializer<?> ser = null;
// Module-provided custom collection serializers?
for (Serializers serializers : customSerializers()) {
ser = serializers.findArraySerializer(config,
type, beanDesc, elementTypeSerializer, elementValueSerializer);
if (ser != null) {
break;
}
}
if (ser == null) {
Class<?> raw = type.getRawClass();
// Important: do NOT use standard serializers if non-standard element value serializer specified
if (elementValueSerializer == null || ClassUtil.isJacksonStdImpl(element
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>ValueSerializer)) {
if (String[].class == raw) {
ser = StringArraySerializer.instance;
} else {
// other standard types?
ser = StdArraySerializers.findStandardImpl(raw);
}
}
if (ser == null) {
ser = new ObjectArraySerializer(type.getContentType(), staticTyping, elementTypeSerializer,
elementValueSerializer);
}
}
// [Issue#120]: Allow post-processing
if (_factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier mod : _factoryConfig.serializerModifiers()) {
ser = mod.modifyArraySerializer(config, type, beanDesc, ser);
}
}
return ser;
}
/*
/**********************************************************
/* Factory methods, for non-container types
/**********************************************************
*/
/**
* @since 2.5
*/
protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config,
JavaType type, BeanDescription beanDesc, boolean staticTyping,
JavaType valueType)
throws JsonMappingException
{
return new IteratorSerializer(valueType, staticTyping, createTypeSerializer(config, valueType), null);
}
@Deprecated // since 2.5
protected JsonSerializer<?> buildIteratorSerializer(SerializationConfig config,
JavaType type, BeanDescription beanDesc, boolean staticTyping) throws JsonMappingException
{
JavaType[] params = config.getTypeFactory().findTypeParameters(type, Iterator.class);
JavaType vt = (params == null || params.length != 1) ?
TypeFactory.unknownType() : params[0];
return buildIteratorSerializer(config, type, beanDesc, staticTyping, vt);
}
/**
* @since 2.5
*/
protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config,
JavaType type, BeanDescription beanDesc, boolean staticTyping,
JavaType valueType)
throws JsonMappingException
{
return new IterableSerializer(valueType, staticTyping, createTypeSerializer(config, valueType), null);
}
@Deprecated // since 2.5
protected JsonSerializer<?> buildIterableSerializer(SerializationConfig config,
JavaType type, BeanDescription beanDesc,
boolean staticTyping)
throws JsonMappingException
{
JavaType[] params = config.getTypeFactory().findTypeParameters(type, Iterable.class);
JavaType vt =
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> methodName, Class<?> noneClass)
{
if (src == null) {
return null;
}
if (!(src instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector."+methodName+"() returned value of type "+src.getClass().getName()+": expected type JsonSerializer or Class<JsonSerializer> instead");
}
Class<?> cls = (Class<?>) src;
if (cls == noneClass || ClassUtil.isBogusClass(cls)) {
return null;
}
return cls;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import java.io.IOException;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
/**
* Simple serializer for {@link InetSocketAddress}.
*/
@SuppressWarnings("serial")
public class InetSocketAddressSerializer
extends StdScalarSerializer<InetSocketAddress>
{
public InetSocketAddressSerializer() { super(InetSocketAddress.class); }
@Override
public void serialize(InetSocketAddress value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
InetAddress addr = value.getAddress();
String str = addr == null ? value.getHostName() : addr.toString().trim();
int ix = str.indexOf('/');
if (ix >= 0) {
if (ix == 0) { // missing host name; use address
str = addr instanceof Inet6Address
? "[" + str.substring(1) + "]" // bracket IPv6 addresses with
: str.substring(1);
} else { // otherwise use name
str = str.substring(0, ix);
}
}
jgen.writeString(str + ":" + value.getPort());
}
@Override
public void serializeWithType(InetSocketAddress value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException, JsonGenerationException
{
// Better ensure we don't use specific sub-classes...
typeSer.writeTypePrefixForScalar(value, jgen, InetSocketAddress.class);
serialize(value, jgen, provider);
typeSer.writeTypeSuffixForScalar(value, jgen);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> changed to only include non-null properties, or properties
* with non-default values.
*/
protected JsonInclude.Include _serializationInclusion = null;
/**
* Object used for resolving filter ids to filter instances.
* Non-null if explicitly defined; null by default.
*/
protected final FilterProvider _filterProvider;
/**
* States of {@link com.fasterxml.jackson.core.JsonGenerator.Feature}s to enable/disable.
*/
protected final int _generatorFeatures;
/**
* Bitflag of {@link com.fasterxml.jackson.core.JsonGenerator.Feature}s to enable/disable
*/
protected final int _generatorFeaturesToChange;
/*
/**********************************************************
/* Life-cycle, constructors
/**********************************************************
*/
/**
* Constructor used by ObjectMapper to create default configuration object instance.
*/
public SerializationConfig(BaseSettings base,
SubtypeResolver str, Map<ClassKey,Class<?>> mixins)
{
super(base, str, mixins);
_serFeatures = collectFeatureDefaults(SerializationFeature.class);
_filterProvider = null;
_generatorFeatures = 0;
_generatorFeaturesToChange = 0;
}
private SerializationConfig(SerializationConfig src, SubtypeResolver str)
{
super(src, str);
_serFeatures = src._serFeatures;
_serializationInclusion = src._serializationInclusion;
_filterProvider = src._filterProvider;
_generatorFeatures = src._generatorFeatures;
_generatorFeaturesToChange = src._generatorFeaturesToChange;
}
private SerializationConfig(SerializationConfig src,
int mapperFeatures, int serFeatures,
int generatorFeatures, int generatorFeatureMask)
{
super(src, mapperFeatures);
_serFeatures = serFeatures;
_serializationInclusion = src._serializationInclusion;
_filterProvider = src._filterProvider;
_generatorFeatures = generatorFeatures;
_generatorFeaturesToChange = generatorFeatureMask;
}
private SerializationConfig(SerializationConfig src, BaseSettings base)
{
super(src, base);
_serFeatures = src._serFeatures;
_serializationInclusion = src._serializationInclusion;
_filterProvider = src._filterProvider;
_generatorFeatures = src._generatorFeatures;
_generatorFeaturesToChange = src._generatorFeaturesToChange;
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.util;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.type.TypeFactory;
/**
* Standard implementation of {@link Converter} that supports explicit
* type access, instead of relying type detection of generic type
* parameters.
*
* @since 2.2
*/
public abstract class StdConverter<IN,OUT>
implements Converter<IN,OUT>
{
/*
/**********************************************************
/* Partial Converter API implementation
/**********************************************************
*/
@Override
public abstract OUT convert(IN value);
@Override
public JavaType getInputType(TypeFactory typeFactory)
{
JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class);
if (types == null || types.length < 2) {
throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName());
}
return types[0];
}
@Override
public JavaType getOutputType(TypeFactory typeFactory)
{
JavaType[] types = typeFactory.findTypeParameters(getClass(), Converter.class);
if (types == null || types.length < 2) {
throw new IllegalStateException("Can not find OUT type parameter for Converter of type "+getClass().getName());
}
return types[1];
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, StringBuffer toAppendTo,
FieldPosition fieldPosition)
{
if (_formatISO8601 == null) {
_formatISO8601 = _cloneFormat(DATE_FORMAT_ISO8601, DATE_FORMAT_STR_ISO8601, _timezone, _locale);
}
return _formatISO8601.format(date, toAppendTo, fieldPosition);
}
/*
/**********************************************************
/* Std overrides
/**********************************************************
*/
@Override
public String toString() {
String str = "DateFormat "+getClass().getName();
TimeZone tz = _timezone;
if (tz != null) {
str += " (timezone: "+tz+")";
}
str += "(locale: "+_locale+")";
return str;
}
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
/**
* Overridable helper method used to figure out which of supported
* formats is the likeliest match.
*/
protected boolean looksLikeISO8601(String dateStr)
{
if (dateStr.length() >= 5
&& Character.isDigit(dateStr.charAt(0))
&& Character.isDigit(dateStr.charAt(3))
&& dateStr.charAt(4) == '-'
) {
return true;
}
return false;
}
protected Date parseAsISO8601(String dateStr, ParsePosition pos)
{
/* 21-May-2009, tatu: DateFormat has very strict handling of
* timezone modifiers for ISO-8601. So we need to do some scrubbing.
*/
/* First: do we have "zulu" format ('Z' == "GMT")? If yes, that's
* quite simple because we already set date format timezone to be
* GMT, and hence can just strip out 'Z' altogether
*/
int len = dateStr.length();
char c = dateStr.charAt(len-1);
DateFormat df;
// [JACKSON-200]: need to support "plain" date...
if (len <= 10 && Character.isDigit(c)) {
df = _formatPlain;
if (df == null) {
df = _formatPlain
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>str = new SerializedString(_simpleName);
} else {
sstr = config.compileString(_simpleName);
}
_encodedSimple = sstr;
}
return sstr;
}
public String getNamespace() {
return _namespace;
}
public boolean hasSimpleName() {
return _simpleName.length() > 0;
}
/**
* @since 2.3
*/
public boolean hasSimpleName(String str) {
if (str == null) {
return _simpleName == null;
}
return str.equals(_simpleName);
}
public boolean hasNamespace() {
return _namespace != null;
}
/**
* Method that is basically equivalent of:
*<pre>
* !hasSimpleName() && !hasNamespace();
*</pre>
*
* @since 2.4
*/
public boolean isEmpty() {
return (_namespace == null) && (_simpleName.isEmpty());
}
/*
/**********************************************************
/* Std method overrides
/**********************************************************
*/
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
/* 13-Nov-2012, tatu: by default, require strict type equality.
* Re-evaluate if this becomes an issue.
*/
if (o.getClass() != getClass()) return false;
// 13-Nov-2012, tatu: Should we have specific rules on matching USE_DEFAULT?
// (like, it only ever matching exact instance)
// If we did, would need to check symmetrically; that is, if either 'this'
// or 'o' was USE_DEFAULT, both would have to be.
PropertyName other = (PropertyName) o;
if (_simpleName == null) {
if (other._simpleName != null) return false;
} else if (!_simpleName.equals(other._simpleName)) {
return false;
}
if (_namespace == null) {
return (null == other._namespace);
}
return _namespace.equals(other._namespace);
}
@Override
public int hashCode() {
if (_namespace == null) {
return _simpleName.hashCode();
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>type annotations,
* find out full type, and figure out which actual factory method
* to call.
*/
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> _createDeserializer(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// First things first: do we need to use abstract type mapping?
if (type.isAbstract() || type.isMapLikeType() || type.isCollectionLikeType()) {
type = factory.mapAbstractType(config, type);
}
BeanDescription beanDesc;
try {
beanDesc = config.introspect(type);
} catch (NoClassDefFoundError error) {
return new NoClassDefFoundDeserializer<Object>(error);
}
// Then: does type define explicit deserializer to use, with annotation(s)?
JsonDeserializer<Object> deser = findDeserializerFromAnnotation(ctxt,
beanDesc.getClassInfo());
if (deser != null) {
return deser;
}
// If not, may have further type-modification annotations to check:
JavaType newType = modifyTypeByAnnotation(ctxt, beanDesc.getClassInfo(), type);
if (newType != type) {
type = newType;
beanDesc = config.introspect(newType);
}
// We may also have a Builder type to consider...
Class<?> builder = beanDesc.findPOJOBuilder();
if (builder != null) {
return (JsonDeserializer<Object>) factory.createBuilderBasedDeserializer(
ctxt, type, beanDesc, builder);
}
// Or perhaps a Converter?
Converter<Object,Object> conv = beanDesc.findDeserializationConverter();
if (conv == null) { // nope, just construct in normal way
return (JsonDeserializer<Object>) _createDeserializer2(ctxt, factory, type, beanDesc);
}
// otherwise need to do bit of introspection
JavaType delegateType = conv.getInputType(ctxt.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
}
return new StdDelegatingDeserializer<Object>(conv
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, delegateType,
_createDeserializer2(ctxt, factory, delegateType, beanDesc));
}
protected JsonDeserializer<?> _createDeserializer2(DeserializationContext ctxt,
DeserializerFactory factory, JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
// If not, let's see which factory method to use:
if (type.isEnumType()) {
return factory.createEnumDeserializer(ctxt, type, beanDesc);
}
if (type.isContainerType()) {
if (type.isArrayType()) {
return factory.createArrayDeserializer(ctxt, (ArrayType) type, beanDesc);
}
if (type.isMapLikeType()) {
MapLikeType mlt = (MapLikeType) type;
if (mlt.isTrueMapType()) {
return factory.createMapDeserializer(ctxt,(MapType) mlt, beanDesc);
}
return factory.createMapLikeDeserializer(ctxt, mlt, beanDesc);
}
if (type.isCollectionLikeType()) {
/* 03-Aug-2012, tatu: As per [Issue#40], one exception is if shape
* is to be Shape.OBJECT. Ideally we'd determine it bit later on
* (to allow custom handler checks), but that won't work for other
* reasons. So do it here.
*/
JsonFormat.Value format = beanDesc.findExpectedFormat(null);
if (format == null || format.getShape() != JsonFormat.Shape.OBJECT) {
CollectionLikeType clt = (CollectionLikeType) type;
if (clt.isTrueCollectionType()) {
return factory.createCollectionDeserializer(ctxt, (CollectionType) clt, beanDesc);
}
return factory.createCollectionLikeDeserializer(ctxt, clt, beanDesc);
}
}
}
if (JsonNode.class.isAssignableFrom(type.getRawClass())) {
return factory.createTreeDeserializer(config, type, beanDesc);
}
return factory.createBeanDeserializer(ctxt, type, beanDesc);
}
/**
* Helper method called to check if a class or method
* has annotation that tells which class to use for deserialization.
* Returns null if no such annotation found.
*/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> }
}
// and finally content class; only applicable to structured types
Class<?> cc = intr.findDeserializationContentType(a, type.getContentType());
if (cc != null) {
try {
type = type.narrowContentsBy(cc);
} catch (IllegalArgumentException iae) {
throw new JsonMappingException("Failed to narrow content type "+type+" with content-type annotation ("+cc.getName()+"): "+iae.getMessage(), null, iae);
}
}
// ... as well as deserializer for contents:
JavaType contentType = type.getContentType();
if (contentType.getValueHandler() == null) { // as with above, avoid resetting (which would trigger exception)
Object cdDef = intr.findContentDeserializer(a);
if (cdDef != null) {
JsonDeserializer<?> cd = null;
if (cdDef instanceof JsonDeserializer<?>) {
cdDef = (JsonDeserializer<?>) cdDef;
} else {
Class<?> cdClass = _verifyAsClass(cdDef, "findContentDeserializer", JsonDeserializer.None.class);
if (cdClass != null) {
cd = ctxt.deserializerInstance(a, cdClass);
}
}
if (cd != null) {
type = type.withContentValueHandler(cd);
}
}
}
}
return type;
}
/*
/**********************************************************
/* Helper methods, other
/**********************************************************
*/
/**
* Helper method used to prevent both caching and cache lookups for structured
* types that have custom value handlers
*
* @since 2.4.6
*/
private boolean _hasCustomValueHandler(JavaType t) {
if (t.isContainerType()) {
JavaType ct = t.getContentType();
return (ct != null) && (ct.getValueHandler() != null);
}
return false;
}
private Class<?> _verifyAsClass(Object src, String methodName, Class<?> noneClass)
{
if (src == null) {
return null;
}
if (!(src instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector."+methodName+"() returned value of type "+src.getClass().getName()+": expected type JsonSerializer or Class<JsonSerializer> instead");
}
Class<?> cls = (Class<?>) src;
if
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(); }
@Override
public Member getMember() { return _field; }
@Override
public void setValue(Object pojo, Object value) throws IllegalArgumentException
{
try {
_field.set(pojo, value);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException("Failed to setValue() for field "
+getFullName()+": "+e.getMessage(), e);
}
}
@Override
public Object getValue(Object pojo) throws IllegalArgumentException
{
try {
return _field.get(pojo);
} catch (IllegalAccessException e) {
throw new IllegalArgumentException("Failed to getValue() for field "
+getFullName()+": "+e.getMessage(), e);
}
}
/*
/**********************************************************
/* Extended API, generic
/**********************************************************
*/
public String getFullName() {
return getDeclaringClass().getName() + "#" + getName();
}
public int getAnnotationCount() { return _annotations.size(); }
@Override
public int hashCode() {
return _field.getName().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
return ((AnnotatedField) o)._field == _field;
}
@Override
public String toString() {
return "[field "+getFullName()+"]";
}
/*
/**********************************************************
/* JDK serialization handling
/**********************************************************
*/
Object writeReplace() {
return new AnnotatedField(new Serialization(_field));
}
Object readResolve() {
Class<?> clazz = _serialization.clazz;
try {
Field f = clazz.getDeclaredField(_serialization.name);
// 06-Oct-2012, tatu: Has "lost" its security override, may need to force back
if (!f.isAccessible()) {
ClassUtil.checkAndFixAccess(f);
}
return new AnnotatedField(null, f, null);
} catch (Exception e) {
throw new IllegalArgumentException("Could not find method '"+_serialization.name
+"' from Class '"+clazz.getName());
}
}
/**
* Helper class that is used as the workaround to persist
* Field references. It basically just stores declaring class
* and field name.
*/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> of contained values
*/
protected final JavaType _valueType;
/**
* Key serializer to use, if it can be statically determined
*/
protected JsonSerializer<Object> _keySerializer;
/**
* Value serializer to use, if it can be statically determined
*/
protected JsonSerializer<Object> _valueSerializer;
/**
* Type identifier serializer used for values, if any.
*/
protected final TypeSerializer _valueTypeSerializer;
/**
* If value type can not be statically determined, mapping from
* runtime value types to serializers are stored in this object.
*/
protected PropertySerializerMap _dynamicValueSerializers;
/**
* Id of the property filter to use, if any; null if none.
*
* @since 2.3
*/
protected final Object _filterId;
/**
* Flag set if output is forced to be sorted by keys (usually due
* to annotation).
*
* @since 2.4
*/
protected final boolean _sortKeys;
/**
* Value that indicates suppression mechanism to use; either one of
* values of {@link com.fasterxml.jackson.annotation.JsonInclude.Include}, or actual object to compare
* against ("default value")
*
* @since 2.5
*/
protected final Object _suppressableValue;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* @since 2.5
*/
@SuppressWarnings("unchecked")
protected MapSerializer(HashSet<String> ignoredEntries,
JavaType keyType, JavaType valueType, boolean valueTypeIsStatic,
TypeSerializer vts,
JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer)
{
super(Map.class, false);
_ignoredEntries = ignoredEntries;
_keyType = keyType;
_valueType = valueType;
_valueTypeIsStatic = valueTypeIsStatic;
_valueTypeSerializer = vts;
_keySerializer = (JsonSerializer<Object>) keySerializer;
_valueSerializer = (JsonSerializer<Object>) valueSerializer;
_dynamicValueSerializers = PropertySerializerMap.emptyForProperties();
_property = null;
_filterId = null;
_sortKeys = false;
_suppressableValue = null;
}
/**
* @since 2.5
*/
protected void _ensure
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Override() {
if (getClass() != MapSerializer.class) {
throw new IllegalStateException("Missing override in class "+getClass().getName());
}
}
@SuppressWarnings("unchecked")
protected MapSerializer(MapSerializer src, BeanProperty property,
JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer,
HashSet<String> ignored)
{
super(Map.class, false);
_ignoredEntries = ignored;
_keyType = src._keyType;
_valueType = src._valueType;
_valueTypeIsStatic = src._valueTypeIsStatic;
_valueTypeSerializer = src._valueTypeSerializer;
_keySerializer = (JsonSerializer<Object>) keySerializer;
_valueSerializer = (JsonSerializer<Object>) valueSerializer;
_dynamicValueSerializers = src._dynamicValueSerializers;
_property = property;
_filterId = src._filterId;
_sortKeys = src._sortKeys;
_suppressableValue = src._suppressableValue;
}
@Deprecated // since 2.5
protected MapSerializer(MapSerializer src, TypeSerializer vts) {
this(src, vts, src._suppressableValue);
}
/**
* @since 2.5
*/
protected MapSerializer(MapSerializer src, TypeSerializer vts,
Object suppressableValue)
{
super(Map.class, false);
_ignoredEntries = src._ignoredEntries;
_keyType = src._keyType;
_valueType = src._valueType;
_valueTypeIsStatic = src._valueTypeIsStatic;
_valueTypeSerializer = vts;
_keySerializer = src._keySerializer;
_valueSerializer = src._valueSerializer;
_dynamicValueSerializers = src._dynamicValueSerializers;
_property = src._property;
_filterId = src._filterId;
_sortKeys = src._sortKeys;
_suppressableValue = suppressableValue;
}
protected MapSerializer(MapSerializer src, Object filterId, boolean sortKeys)
{
super(Map.class, false);
_ignoredEntries = src._ignoredEntries;
_keyType = src._keyType;
_valueType = src._valueType;
_valueTypeIsStatic = src._valueTypeIsStatic;
_valueTypeSerializer = src._valueTypeSerializer;
_keySerializer = src._keySerializer;
_valueSerializer = src
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> keyType = mapType.getKeyType();
valueType = mapType.getContentType();
}
// If value type is final, it's same as forcing static value typing:
if (!staticValueType) {
staticValueType = (valueType != null && valueType.isFinal());
} else {
// also: Object.class can not be handled as static, ever
if (valueType.getRawClass() == Object.class) {
staticValueType = false;
}
}
MapSerializer ser = new MapSerializer(ignoredEntries, keyType, valueType, staticValueType, vts,
keySerializer, valueSerializer);
if (filterId != null) {
ser = ser.withFilterId(filterId);
}
return ser;
}
/*
/**********************************************************
/* Post-processing (contextualization)
/**********************************************************
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property)
throws JsonMappingException
{
/* 29-Sep-2012, tatu: Actually, we need to do much more contextual
* checking here since we finally know for sure the property,
* and it may have overrides
*/
JsonSerializer<?> ser = null;
JsonSerializer<?> keySer = null;
final AnnotationIntrospector intr = provider.getAnnotationIntrospector();
final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember();
Object suppressableValue = _suppressableValue;
// First: if we have a property, may have property-annotation overrides
if (propertyAcc != null && intr != null) {
Object serDef = intr.findKeySerializer(propertyAcc);
if (serDef != null) {
keySer = provider.serializerInstance(propertyAcc, serDef);
}
serDef = intr.findContentSerializer(propertyAcc);
if (serDef != null) {
ser = provider.serializerInstance(propertyAcc, serDef);
}
JsonInclude.Include incl = intr.findSerializationInclusionForContent(propertyAcc, null);
if (incl != null) {
suppressableValue = incl;
}
}
if (ser == null) {
ser = _valueSerializer;
}
// [Issue#124]: May have a content converter
ser = findConvertingContent
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Serializer(provider, property, ser);
if (ser == null) {
// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
// we can consider it a static case as well.
// 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho
if ((_valueTypeIsStatic && _valueType.getRawClass() != Object.class)
|| hasContentTypeAnnotation(provider, property)) {
ser = provider.findValueSerializer(_valueType, property);
}
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
if (keySer == null) {
keySer = _keySerializer;
}
if (keySer == null) {
keySer = provider.findKeySerializer(_keyType, property);
} else {
keySer = provider.handleSecondaryContextualization(keySer, property);
}
HashSet<String> ignored = _ignoredEntries;
boolean sortKeys = false;
if (intr != null && propertyAcc != null) {
String[] moreToIgnore = intr.findPropertiesToIgnore(propertyAcc);
if (moreToIgnore != null) {
ignored = (ignored == null) ? new HashSet<String>() : new HashSet<String>(ignored);
for (String str : moreToIgnore) {
ignored.add(str);
}
}
Boolean b = intr.findSerializationSortAlphabetically(propertyAcc);
sortKeys = (b != null) && b.booleanValue();
}
MapSerializer mser = withResolved(property, keySer, ser, ignored, sortKeys);
if (suppressableValue != _suppressableValue) {
mser = mser.withContentInclusion(suppressableValue);
}
// [Issue#307]: allow filtering
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null) {
Object filterId = intr.findFilterId(m);
if (filterId != null) {
mser = mser.withFilterId(filterId);
}
}
}
return mser;
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>valueSerializer);
} else {
serializeFields(value, gen, provider);
}
}
gen.writeEndObject();
}
@Override
public void serializeWithType(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException
{
typeSer.writeTypePrefixForObject(value, gen);
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
if (!value.isEmpty()) {
Object suppressableValue = _suppressableValue;
if (suppressableValue == null) {
if (!provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES)) {
suppressableValue = JsonInclude.Include.NON_NULL;
}
} else if (suppressableValue == JsonInclude.Include.ALWAYS) {
suppressableValue = null;
}
if (_sortKeys || provider.isEnabled(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS)) {
value = _orderEntries(value);
}
if (_filterId != null) {
serializeFilteredFields(value, gen, provider,
findPropertyFilter(provider, _filterId, value), suppressableValue);
} else if (suppressableValue != null) {
serializeOptionalFields(value, gen, provider, suppressableValue);
} else if (_valueSerializer != null) {
serializeFieldsUsing(value, gen, provider, _valueSerializer);
} else {
serializeFields(value, gen, provider);
}
}
typeSer.writeTypeSuffixForObject(value, gen);
}
/*
/**********************************************************
/* JsonSerializer implementation
/**********************************************************
*/
/**
* Method called to serialize fields, when the value type is not statically known;
* but we know that no value suppression is needed (which simplifies processing a bit)
*/
public void serializeFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider)
throws IOException
{
// If value type needs polymorphic type handling, some more work needed:
if (_valueTypeSerializer != null) {
serializeTypedFields(value, gen, provider, null);
return;
}
final JsonSerializer<Object> keySerializer = _keySerializer;
final HashSet<String> ignored = _ignoredEntries;
PropertySerializerMap serializers
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> = _dynamicValueSerializers;
for (Map.Entry<?,?> entry : value.entrySet()) {
Object valueElem = entry.getValue();
// First, serialize key
Object keyElem = entry.getKey();
if (keyElem == null) {
provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider);
} else {
// One twist: is entry ignorable? If so, skip
if (ignored != null && ignored.contains(keyElem)) continue;
keySerializer.serialize(keyElem, gen, provider);
}
// And then value
if (valueElem == null) {
provider.defaultSerializeNull(gen);
} else {
Class<?> cc = valueElem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
if (_valueType.hasGenericTypes()) {
serializer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_valueType, cc), provider);
} else {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicValueSerializers;
}
try {
serializer.serialize(valueElem, gen, provider);
} catch (Exception e) {
// Add reference information
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
}
public void serializeOptionalFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
Object suppressableValue)
throws IOException
{
// If value type needs polymorphic type handling, some more work needed:
if (_valueTypeSerializer != null) {
serializeTypedFields(value, gen, provider, suppressableValue);
return;
}
final HashSet<String> ignored = _ignoredEntries;
PropertySerializerMap serializers = _dynamicValueSerializers;
for (Map.Entry<?,?> entry : value.entrySet()) {
// First find key serializer
final Object keyElem = entry.getKey();
JsonSerializer<Object> keySerializer;
if (keyElem == null) {
keySerializer = provider.findNullKeySerializer(_keyType, _property);
} else {
if (ignored != null && ignored.contains(keyElem)) continue;
keySerializer = _keySerializer;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> // Then value serializer
final Object valueElem = entry.getValue();
JsonSerializer<Object> valueSer;
if (valueElem == null) {
if (suppressableValue != null) { // all suppressions include null-suppression
continue;
}
valueSer = provider.getDefaultNullValueSerializer();
} else {
valueSer = _valueSerializer;
if (valueSer == null) {
Class<?> cc = valueElem.getClass();
valueSer = serializers.serializerFor(cc);
if (valueSer == null) {
if (_valueType.hasGenericTypes()) {
valueSer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_valueType, cc), provider);
} else {
valueSer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicValueSerializers;
}
}
// also may need to skip non-empty values:
if ((suppressableValue == JsonInclude.Include.NON_EMPTY)
&& valueSer.isEmpty(provider, valueElem)) {
continue;
}
}
// and then serialize, if all went well
try {
keySerializer.serialize(keyElem, gen, provider);
valueSer.serialize(valueElem, gen, provider);
} catch (Exception e) {
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
/**
* Method called to serialize fields, when the value type is statically known,
* so that value serializer is passed and does not need to be fetched from
* provider.
*/
protected void serializeFieldsUsing(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
JsonSerializer<Object> ser)
throws IOException
{
final JsonSerializer<Object> keySerializer = _keySerializer;
final HashSet<String> ignored = _ignoredEntries;
final TypeSerializer typeSer = _valueTypeSerializer;
for (Map.Entry<?,?> entry : value.entrySet()) {
Object keyElem = entry.getKey();
if (ignored != null && ignored.contains(keyElem)) continue;
if (keyElem == null) {
provider.findNullKeySerializer(_keyType, _property).serialize(null, gen, provider);
} else {
keySerializer.serialize(keyElem, gen, provider);
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
final Object valueElem = entry.getValue();
if (valueElem == null) {
provider.defaultSerializeNull(gen);
} else {
try {
if (typeSer == null) {
ser.serialize(valueElem, gen, provider);
} else {
ser.serializeWithType(valueElem, gen, provider, typeSer);
}
} catch (Exception e) {
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
}
/**
* Helper method used when we have a JSON Filter to use for potentially
* filtering out Map entries.
*
* @since 2.5
*/
public void serializeFilteredFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
PropertyFilter filter,
Object suppressableValue) // since 2.5
throws IOException
{
final HashSet<String> ignored = _ignoredEntries;
PropertySerializerMap serializers = _dynamicValueSerializers;
final MapProperty prop = new MapProperty(_valueTypeSerializer, _property);
for (Map.Entry<?,?> entry : value.entrySet()) {
// First, serialize key; unless ignorable by key
final Object keyElem = entry.getKey();
if (ignored != null && ignored.contains(keyElem)) continue;
JsonSerializer<Object> keySerializer;
if (keyElem == null) {
keySerializer = provider.findNullKeySerializer(_keyType, _property);
} else {
keySerializer = _keySerializer;
}
// or by value; nulls often suppressed
final Object valueElem = entry.getValue();
JsonSerializer<Object> valueSer;
// And then value
if (valueElem == null) {
if (suppressableValue != null) { // all suppressions include null-suppression
continue;
}
valueSer = provider.getDefaultNullValueSerializer();
} else {
valueSer = _valueSerializer;
if (valueSer == null) {
Class<?> cc = valueElem.getClass();
valueSer = serializers.serializerFor(cc);
if (valueSer == null) {
if (_valueType.hasGenericTypes()) {
valueSer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_valueType, cc), provider);
} else {
value
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Ser = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicValueSerializers;
}
}
// also may need to skip non-empty values:
if ((suppressableValue == JsonInclude.Include.NON_EMPTY)
&& valueSer.isEmpty(provider, valueElem)) {
continue;
}
}
// and with that, ask filter to handle it
prop.reset(keyElem, keySerializer, valueSer);
try {
filter.serializeAsField(valueElem, gen, provider, prop);
} catch (Exception e) {
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
@Deprecated // since 2.5
public void serializeFilteredFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
PropertyFilter filter) throws IOException {
serializeFilteredFields(value, gen, provider, filter,
provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES) ? null : JsonInclude.Include.NON_NULL);
}
/**
* @since 2.5
*/
protected void serializeTypedFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider,
Object suppressableValue) // since 2.5
throws IOException
{
final HashSet<String> ignored = _ignoredEntries;
PropertySerializerMap serializers = _dynamicValueSerializers;
for (Map.Entry<?,?> entry : value.entrySet()) {
Object keyElem = entry.getKey();
JsonSerializer<Object> keySerializer;
if (keyElem == null) {
keySerializer = provider.findNullKeySerializer(_keyType, _property);
} else {
// One twist: is entry ignorable? If so, skip
if (ignored != null && ignored.contains(keyElem)) continue;
keySerializer = _keySerializer;
}
final Object valueElem = entry.getValue();
// And then value
JsonSerializer<Object> valueSer;
if (valueElem == null) {
if (suppressableValue != null) { // all suppression include null suppression
continue;
}
valueSer = provider.getDefaultNullValueSerializer();
} else {
valueSer = _valueSerializer;
Class<?> cc = valueElem.getClass();
valueSer = serializers.serializer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>For(cc);
if (valueSer == null) {
if (_valueType.hasGenericTypes()) {
valueSer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_valueType, cc), provider);
} else {
valueSer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicValueSerializers;
}
// also may need to skip non-empty values:
if ((suppressableValue == JsonInclude.Include.NON_EMPTY)
&& valueSer.isEmpty(provider, valueElem)) {
continue;
}
}
keySerializer.serialize(keyElem, gen, provider);
try {
valueSer.serializeWithType(valueElem, gen, provider, _valueTypeSerializer);
} catch (Exception e) {
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
@Deprecated // since 2.5
protected void serializeTypedFields(Map<?,?> value, JsonGenerator gen, SerializerProvider provider)
throws IOException {
serializeTypedFields(value, gen, provider,
provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES) ? null : JsonInclude.Include.NON_NULL);
}
/*
/**********************************************************
/* Schema related functionality
/**********************************************************
*/
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
ObjectNode o = createSchemaNode("object", true);
//(ryan) even though it's possible to statically determine the "value" type of the map,
// there's no way to statically determine the keys, so the "Entries" can't be determined.
return o;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonMapFormatVisitor v2 = (visitor == null) ? null : visitor.expectMapFormat(typeHint);
if (v2 != null) {
v2.keyFormat(_keySerializer, _keyType);
JsonSerializer<?> valueSer = _valueSerializer;
if (valueSer == null) {
valueSer = _findAndAddDynamic(_dynamicValueSerializers,
_valueType, visitor.getProvider());
}
v2.valueFormat(valueSer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonStringFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonValueFormat;
@JacksonStdImpl
@SuppressWarnings("serial")
public class SqlTimeSerializer
extends StdScalarSerializer<java.sql.Time>
{
public SqlTimeSerializer() { super(java.sql.Time.class); }
@Override
public void serialize(java.sql.Time value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
jgen.writeString(value.toString());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonStringFormatVisitor v2 = (visitor == null) ? null : visitor.expectStringFormat(typeHint);
if (v2 != null) {
v2.format(JsonValueFormat.DATE_TIME);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> // Issue#381
if (t == JsonToken.START_ARRAY && ctxt.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS)) {
jp.nextToken();
final String parsed = _parseString(jp, ctxt);
if (jp.nextToken() != JsonToken.END_ARRAY) {
throw ctxt.wrongTokenException(jp, JsonToken.END_ARRAY,
"Attempted to unwrap single value array for single 'String' value but there was more than a single value in the array");
}
return parsed;
}
String value = jp.getValueAsString();
if (value != null) {
return value;
}
throw ctxt.mappingException(String.class, jp.getCurrentToken());
}
/**
* Helper method that may be used to support fallback for Empty String / Empty Array
* non-standard representations; usually for things serialized as JSON Objects.
*
* @since 2.5
*/
protected T _deserializeFromEmpty(JsonParser jp, DeserializationContext ctxt)
throws IOException
{
JsonToken t = jp.getCurrentToken();
if (t == JsonToken.START_ARRAY) {
if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT)) {
t = jp.nextToken();
if (t == JsonToken.END_ARRAY) {
return null;
}
throw ctxt.mappingException(handledType(), JsonToken.START_ARRAY);
}
} else if (t == JsonToken.VALUE_STRING) {
if (ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
String str = jp.getText().trim();
if (str.isEmpty()) {
return null;
}
}
}
throw ctxt.mappingException(handledType());
}
/**
* Helper method called to determine if we are seeing String value of
* "null", and, further, that it should be coerced to null just like
* null token.
*
* @since 2.3
*/
protected boolean _hasTextualNull(String value) {
return "null".equals(value);
}
protected final boolean _isNegInf(String text) {
return "-Infinity".equals(text) || "-INF".equals(text);
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ObjectBuffer;
/**
* Separate implementation for serializing String arrays (instead of
* using {@link ObjectArrayDeserializer}.
* Used if (and only if) no custom value deserializers are used.
*/
@JacksonStdImpl
public final class StringArrayDeserializer
extends StdDeserializer<String[]>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
public final static StringArrayDeserializer instance = new StringArrayDeserializer();
/**
* Value serializer to use, if not the standard one (which is inlined)
*/
protected JsonDeserializer<String> _elementDeserializer;
public StringArrayDeserializer() {
super(String[].class);
_elementDeserializer = null;
}
@SuppressWarnings("unchecked")
protected StringArrayDeserializer(JsonDeserializer<?> deser) {
super(String[].class);
_elementDeserializer = (JsonDeserializer<String>) deser;
}
@Override
public String[] deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
// Ok: must point to START_ARRAY (or equivalent)
if (!jp.isExpectedStartArrayToken()) {
return handleNonArray(jp, ctxt);
}
if (_elementDeserializer != null) {
return _deserializeCustom(jp, ctxt);
}
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] chunk = buffer.resetAndStart();
int ix = 0;
try {
while (true) {
String value = jp.nextTextValue();
if (value == null) {
JsonToken t = jp.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
if (t != JsonToken.VALUE_NULL) {
value = _parseString(jp, ctxt);
}
}
if (ix >= chunk.length) {
chunk = buffer.append
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>CompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, chunk, buffer.bufferedSize() + ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
/**
* Offlined version used when we do not use the default deserialization method.
*/
protected final String[] _deserializeCustom(JsonParser jp, DeserializationContext ctxt) throws IOException
{
final ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] chunk = buffer.resetAndStart();
final JsonDeserializer<String> deser = _elementDeserializer;
int ix = 0;
try {
while (true) {
/* 30-Dec-2014, tatu: This may look odd, but let's actually call method
* that suggest we are expecting a String; this helps with some formats,
* notably XML. Note, however, that while we can get String, we can't
* assume that's what we use due to custom deserializer
*/
String value;
if (jp.nextTextValue() == null) {
JsonToken t = jp.getCurrentToken();
if (t == JsonToken.END_ARRAY) {
break;
}
// Ok: no need to convert Strings, but must recognize nulls
value = (t == JsonToken.VALUE_NULL) ? deser.getNullValue() : deser.deserialize(jp, ctxt);
} else {
value = deser.deserialize(jp, ctxt);
}
if (ix >= chunk.length) {
chunk = buffer.appendCompletedChunk(chunk);
ix = 0;
}
chunk[ix++] = value;
}
} catch (Exception e) {
// note: pass String.class, not String[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, String.class, ix);
}
String[] result = buffer.completeAndClearBuffer(chunk, ix, String.class);
ctxt.returnObjectBuffer(buffer);
return result;
}
@Override
public Object deserializeWithType(JsonParser jp, Deserial
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>izationContext ctxt, TypeDeserializer typeDeserializer) throws IOException {
return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
}
private final String[] handleNonArray(JsonParser jp, DeserializationContext ctxt) throws IOException
{
// [JACKSON-526]: implicit arrays from single values?
if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
// [JACKSON-620] Empty String can become null...
if ((jp.getCurrentToken() == JsonToken.VALUE_STRING)
&& ctxt.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) {
String str = jp.getText();
if (str.length() == 0) {
return null;
}
}
throw ctxt.mappingException(_valueClass);
}
return new String[] { (jp.getCurrentToken() == JsonToken.VALUE_NULL) ? null : _parseString(jp, ctxt) };
}
/**
* Contextualization is needed to see whether we can "inline" deserialization
* of String values, or if we have to use separate value deserializer.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt, BeanProperty property) throws JsonMappingException
{
JsonDeserializer<?> deser = _elementDeserializer;
// #125: May have a content converter
deser = findConvertingContentDeserializer(ctxt, property, deser);
JavaType type = ctxt.constructType(String.class);
if (deser == null) {
deser = ctxt.findContextualValueDeserializer(type, property);
} else { // if directly assigned, probably not yet contextual, so:
deser = ctxt.handleSecondaryContextualization(deser, property, type);
}
// Ok ok: if all we got is the default String deserializer, can just forget about it
if (deser != null && this.isDefaultDeserializer(deser)) {
deser = null;
}
if (_elementDeserializer != deser) {
return new StringArrayDeserializer(deser);
}
return this;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.lang.reflect.*;
import java.util.*;
import com.fasterxml.jackson.databind.JavaType;
/**
* Helper class used for resolving type parameters for given class
*/
public class TypeBindings
{
private final static JavaType[] NO_TYPES = new JavaType[0];
/**
* Marker to use for (temporarily) unbound references.
*/
public final static JavaType UNBOUND = new SimpleType(Object.class);
/**
* Factory to use for constructing resolved related types.
*/
protected final TypeFactory _typeFactory;
/**
* Context type used for resolving all types, if specified. May be null,
* in which case {@link #_contextClass} is used instead.
*/
protected final JavaType _contextType;
/**
* Specific class to use for resolving all types, for methods and fields
* class and its superclasses and -interfaces contain.
*/
protected final Class<?> _contextClass;
/**
* Lazily-instantiated bindings of resolved type parameters
*/
protected Map<String,JavaType> _bindings;
/**
* Also: we may temporarily want to mark certain named types
* as resolved (but without exact type); if so, we'll just store
* names here.
*/
protected HashSet<String> _placeholders;
/**
* Sometimes it is necessary to allow hierarchic resolution of types: specifically
* in cases where there are local bindings (for methods, constructors). If so,
* we'll just use simple delegation model.
*/
private final TypeBindings _parentBindings;
/*
/**********************************************************
/* Construction
/**********************************************************
*/
public TypeBindings(TypeFactory typeFactory, Class<?> cc)
{
this(typeFactory, null, cc, null);
}
public TypeBindings(TypeFactory typeFactory, JavaType type)
{
this(typeFactory, null, type.getRawClass(), type);
}
/**
* Constructor used to create "child" instances; mostly to
* allow delegation from explicitly defined local overrides
* (local type variables for methods, constructors) to
* contextual (class-defined) ones.
*/
public TypeBindings childInstance() {
return new TypeBindings(_typeFactory, this, _
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
@JacksonStdImpl
@SuppressWarnings("serial")
public class IterableSerializer
extends AsArraySerializerBase<Iterable<?>>
{
public IterableSerializer(JavaType elemType, boolean staticTyping,
TypeSerializer vts, BeanProperty property)
{
super(Iterable.class, elemType, staticTyping, vts, property, null);
}
public IterableSerializer(IterableSerializer src, BeanProperty property,
TypeSerializer vts, JsonSerializer<?> valueSerializer)
{
super(src, property, vts, valueSerializer);
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return new IterableSerializer(_elementType, _staticTyping, vts, _property);
}
@Override
public IterableSerializer withResolved(BeanProperty property,
TypeSerializer vts, JsonSerializer<?> elementSerializer) {
return new IterableSerializer(this, property, vts, elementSerializer);
}
@Override
public boolean isEmpty(SerializerProvider prov, Iterable<?> value) {
// Not really good way to implement this, but has to do for now:
return (value == null) || !value.iterator().hasNext();
}
@Override
public boolean hasSingleElement(Iterable<?> value) {
// we can do it actually (fixed in 2.3.1)
if (value != null) {
Iterator<?> it = value.iterator();
if (it.hasNext()) {
it.next();
if (!it.hasNext()) {
return true;
}
}
}
return false;
}
@Override
public final void serialize(Iterable<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED) && hasSingleElement(value)) {
serializeContents(value, jgen, provider);
return;
}
jgen
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.writeStartArray();
serializeContents(value, jgen, provider);
jgen.writeEndArray();
}
@Override
public void serializeContents(Iterable<?> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
Iterator<?> it = value.iterator();
if (it.hasNext()) {
final TypeSerializer typeSer = _valueTypeSerializer;
JsonSerializer<Object> prevSerializer = null;
Class<?> prevClass = null;
do {
Object elem = it.next();
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
JsonSerializer<Object> currSerializer = _elementSerializer;
if (currSerializer == null) {
// Minor optimization to avoid most lookups:
Class<?> cc = elem.getClass();
if (cc == prevClass) {
currSerializer = prevSerializer;
} else {
currSerializer = provider.findValueSerializer(cc, _property);
prevSerializer = currSerializer;
prevClass = cc;
}
}
if (typeSer == null) {
currSerializer.serialize(elem, jgen, provider);
} else {
currSerializer.serializeWithType(elem, jgen, provider, typeSer);
}
} while (it.hasNext());
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.util.*;
import com.fasterxml.jackson.databind.JavaType;
/**
* Type that represents Map-like types; things that consist of key/value pairs but that
* do not necessarily implement {@link java.util.Map}, but that do not have enough
* introspection functionality to allow for some level of generic handling.
* This specifically allows framework to check for configuration and annotation
* settings used for Map types, and pass these to custom handlers that may be more
* familiar with actual type.
*/
public class MapLikeType extends TypeBase
{
private static final long serialVersionUID = 416067702302823522L;
/**
* Type of keys of Map.
*/
protected final JavaType _keyType;
/**
* Type of values of Map.
*/
protected final JavaType _valueType;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected MapLikeType(Class<?> mapType, JavaType keyT, JavaType valueT,
Object valueHandler, Object typeHandler, boolean asStatic)
{
super(mapType, keyT.hashCode() ^ valueT.hashCode(), valueHandler, typeHandler, asStatic);
_keyType = keyT;
_valueType = valueT;
}
public static MapLikeType construct(Class<?> rawType, JavaType keyT, JavaType valueT)
{
// nominally component types will be just Object.class
return new MapLikeType(rawType, keyT, valueT, null, null, false);
}
@Override
protected JavaType _narrow(Class<?> subclass) {
return new MapLikeType(subclass, _keyType, _valueType, _valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType narrowContentsBy(Class<?> contentClass)
{
// Can do a quick check first:
if (contentClass == _valueType.getRawClass()) {
return this;
}
return new MapLikeType(_class, _keyType, _valueType.narrowBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public JavaType widenContentsBy(Class<?> contentClass)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> {
if (contentClass == _valueType.getRawClass()) {
return this;
}
return new MapLikeType(_class, _keyType, _valueType.widenBy(contentClass),
_valueHandler, _typeHandler, _asStatic);
}
public JavaType narrowKey(Class<?> keySubclass)
{
// Can do a quick check first:
if (keySubclass == _keyType.getRawClass()) {
return this;
}
return new MapLikeType(_class, _keyType.narrowBy(keySubclass), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
public JavaType widenKey(Class<?> keySubclass)
{
// Can do a quick check first:
if (keySubclass == _keyType.getRawClass()) {
return this;
}
return new MapLikeType(_class, _keyType.widenBy(keySubclass), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapLikeType withTypeHandler(Object h)
{
return new MapLikeType(_class, _keyType, _valueType, _valueHandler, h, _asStatic);
}
@Override
public MapLikeType withContentTypeHandler(Object h)
{
return new MapLikeType(_class, _keyType, _valueType.withTypeHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapLikeType withValueHandler(Object h) {
return new MapLikeType(_class, _keyType, _valueType, h, _typeHandler, _asStatic);
}
@Override
public MapLikeType withContentValueHandler(Object h) {
return new MapLikeType(_class, _keyType, _valueType.withValueHandler(h),
_valueHandler, _typeHandler, _asStatic);
}
@Override
public MapLikeType withStaticTyping() {
if (_asStatic) {
return this;
}
return new MapLikeType(_class, _keyType, _valueType.withStaticTyping(),
_valueHandler, _typeHandler, true);
}
@Override
protected String buildCanonicalName() {
StringBuilder sb = new StringBuilder();
sb.append(_class.getName());
if (_keyType !=
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> null) {
sb.append('<');
sb.append(_keyType.toCanonical());
sb.append(',');
sb.append(_valueType.toCanonical());
sb.append('>');
}
return sb.toString();
}
/*
/**********************************************************
/* Public API
/**********************************************************
*/
@Override
public boolean isContainerType() { return true; }
@Override
public boolean isMapLikeType() { return true; }
@Override
public JavaType getKeyType() { return _keyType; }
@Override
public JavaType getContentType() { return _valueType; }
@Override
public int containedTypeCount() { return 2; }
@Override
public JavaType containedType(int index) {
if (index == 0) return _keyType;
if (index == 1) return _valueType;
return null;
}
/**
* Not sure if we should count on this, but type names
* for core interfaces are "K" and "V" respectively.
* For now let's assume this should work.
*/
@Override
public String containedTypeName(int index) {
if (index == 0) return "K";
if (index == 1) return "V";
return null;
}
// TODO: should allow construction of instances that do refer
// to parameterization, since it is NOT Map
@Override
public Class<?> getParameterSource() {
return null;
}
@Override
public StringBuilder getErasedSignature(StringBuilder sb) {
return _classSignature(_class, sb, true);
}
@Override
public StringBuilder getGenericSignature(StringBuilder sb)
{
_classSignature(_class, sb, false);
sb.append('<');
_keyType.getGenericSignature(sb);
_valueType.getGenericSignature(sb);
sb.append(">;");
return sb;
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
public MapLikeType withKeyTypeHandler(Object h)
{
return new MapLikeType(_class, _keyType.withTypeHandler(h), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
public MapLikeType withKeyValueHandler(Object h) {
return new MapLikeType(_class, _keyType.with
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>ValueHandler(h), _valueType,
_valueHandler, _typeHandler, _asStatic);
}
/**
* Method that can be used for checking whether this type is a
* "real" Collection type; meaning whether it represents a parameterized
* subtype of {@link java.util.Collection} or just something that acts
* like one.
*/
public boolean isTrueMapType() {
return Map.class.isAssignableFrom(_class);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public String toString()
{
return "[map-like type; class "+_class.getName()+", "+_keyType+" -> "+_valueType+"]";
}
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
MapLikeType other = (MapLikeType) o;
return (_class == other._class)
&& _keyType.equals(other._keyType)
&& _valueType.equals(other._valueType);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>String> foundSoFar);
public abstract List<JsonNode> findParents(String fieldName, List<JsonNode> foundSoFar);
/*
/**********************************************************
/* Public API, path handling
/**********************************************************
*/
/**
* Method that can be called on Object nodes, to access a property
* that has Object value; or if no such property exists, to create,
* add and return such Object node.
* If the node method is called on is not Object node,
* or if property exists and has value that is not Object node,
* {@link UnsupportedOperationException} is thrown
*/
public JsonNode with(String propertyName) {
throw new UnsupportedOperationException("JsonNode not of type ObjectNode (but "
+getClass().getName()+"), can not call with() on it");
}
/**
* Method that can be called on Object nodes, to access a property
* that has <code>Array</code> value; or if no such property exists, to create,
* add and return such Array node.
* If the node method is called on is not Object node,
* or if property exists and has value that is not Array node,
* {@link UnsupportedOperationException} is thrown
*/
public JsonNode withArray(String propertyName) {
throw new UnsupportedOperationException("JsonNode not of type ObjectNode (but "
+getClass().getName()+"), can not call withArray() on it");
}
/*
/**********************************************************
/* Overridden standard methods
/**********************************************************
*/
/**
*<p>
* Note: marked as abstract to ensure all implementation
* classes define it properly.
*/
@Override
public abstract String toString();
/**
* Equality for node objects is defined as full (deep) value
* equality. This means that it is possible to compare complete
* JSON trees for equality by comparing equality of root nodes.
*<p>
* Note: marked as abstract to ensure all implementation
* classes define it properly and not rely on definition
* from {@link java.lang.Object}.
*/
@Override
public abstract boolean equals(Object o);
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.lang.reflect.*;
/**
* Simple replacement for {@link java.lang.Class} (and/or various Type subtypes)
* that is used as part of single-path extends/implements chain to express
* specific relationship between one subtype and one supertype. This is needed
* for resolving type parameters. Instances are doubly-linked so that chain
* can be traversed in both directions
*/
public class HierarchicType
{
/**
* Type which will be either plain {@link java.lang.Class} or
* {@link java.lang.reflect.ParameterizedType}.
*/
protected final Type _actualType;
protected final Class<?> _rawClass;
protected final ParameterizedType _genericType;
protected HierarchicType _superType;
protected HierarchicType _subType;
public HierarchicType(Type type)
{
this._actualType = type;
if (type instanceof Class<?>) {
_rawClass = (Class<?>) type;
_genericType = null;
} else if (type instanceof ParameterizedType) {
_genericType = (ParameterizedType) type;
_rawClass = (Class<?>) _genericType.getRawType();
} else { // should never happen... can't extend GenericArrayType?
throw new IllegalArgumentException("Type "+type.getClass().getName()+" can not be used to construct HierarchicType");
}
}
private HierarchicType(Type actualType, Class<?> rawClass, ParameterizedType genericType,
HierarchicType superType, HierarchicType subType)
{
_actualType = actualType;
_rawClass = rawClass;
_genericType = genericType;
_superType = superType;
_subType = subType;
}
/**
* Method that can be used to create a deep clone of this hierarchic type, including
* super types (but not subtypes)
*/
public HierarchicType deepCloneWithoutSubtype()
{
HierarchicType sup = (_superType == null) ? null : _superType.deepCloneWithoutSubtype();
HierarchicType result = new HierarchicType(_actualType, _rawClass, _genericType, sup, null);
if (sup != null)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.convert;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.util.StdConverter;
public class TestConvertingSerializer
extends com.fasterxml.jackson.databind.BaseMapTest
{
@JsonSerialize(converter=ConvertingBeanConverter.class)
static class ConvertingBean
{
public int x, y;
public ConvertingBean(int v1, int v2) {
x = v1;
y = v2;
}
}
static class Point
{
public int x, y;
public Point(int v1, int v2) {
x = v1;
y = v2;
}
}
static class ConvertingBeanContainer
{
public List<ConvertingBean> values;
public ConvertingBeanContainer(ConvertingBean... beans) {
values = Arrays.asList(beans);
}
}
static class ConvertingBeanConverter extends StdConverter<ConvertingBean, int[]>
{
@Override
public int[] convert(ConvertingBean value) {
return new int[] { value.x, value.y };
}
}
static class PointConverter extends StdConverter<Point, int[]>
{
@Override public int[] convert(Point value) {
return new int[] { value.x, value.y };
}
}
static class PointWrapper {
@JsonSerialize(converter=PointConverter.class)
public Point value;
public PointWrapper(int x, int y) {
value = new Point(x, y);
}
}
static class PointListWrapperArray {
@JsonSerialize(contentConverter=PointConverter.class)
public Point[] values;
public PointListWrapperArray(int x, int y) {
values = new Point[] { new Point(x, y), new Point(y, x) };
}
}
static class PointListWrapperList {
@JsonSerialize(contentConverter=PointConverter.class)
public List<Point> values;
public
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> PointListWrapperList(int x, int y) {
values = Arrays.asList(new Point[] { new Point(x, y), new Point(y, x) });
}
}
static class PointListWrapperMap {
@JsonSerialize(contentConverter=PointConverter.class)
public Map<String,Point> values;
public PointListWrapperMap(String key, int x, int y) {
values = new HashMap<String,Point>();
values.put(key, new Point(x, y));
}
}
// [Issue#359]
static class Bean359 {
@JsonSerialize(as = List.class, contentAs = Source.class)
public List<Source> stuff = Arrays.asList(new Source());
}
@JsonSerialize(using = TargetSerializer.class)
static class Target {
public String unexpected = "Bye.";
}
@JsonSerialize(converter = SourceToTargetConverter.class)
static class Source { }
static class SourceToTargetConverter extends StdConverter<Source, Target> {
@Override
public Target convert(Source value) {
return new Target();
}
}
static class TargetSerializer extends JsonSerializer<Target>
{
@Override
public void serialize(Target a, JsonGenerator jsonGenerator, SerializerProvider provider) throws IOException {
jsonGenerator.writeString("Target");
}
}
// [Issue#731]
public static class DummyBean {
public final int a, b;
public DummyBean(int v1, int v2) {
a = v1 * 2;
b = v2 * 2;
}
}
@JsonSerialize(converter = UntypedConvertingBeanConverter.class)
static class ConvertingBeanWithUntypedConverter {
public int x, y;
public ConvertingBeanWithUntypedConverter(int v1, int v2) {
x = v1;
y = v2;
}
}
static class UntypedConvertingBeanConverter extends StdConverter<ConvertingBeanWithUntypedConverter, Object>
{
@Override
public Object convert(ConvertingBeanWithUntypedConverter cb) {
return new DummyBean(cb.x, cb.y);
}
}
/*
/**********************************************************
/* Test methods
/**********************************************************
*/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.lang.reflect.Type;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
/**
* This is a simple dummy serializer that will just output literal
* JSON null value whenever serialization is requested.
* Used as the default "null serializer" (which is used for serializing
* null object references unless overridden), as well as for some
* more exotic types (java.lang.Void).
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class NullSerializer
extends StdSerializer<Object>
{
public final static NullSerializer instance = new NullSerializer();
private NullSerializer() { super(Object.class); }
@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
gen.writeNull();
}
/**
* Although this method should rarely get called, for convenience we should override
* it, and handle it same way as "natural" types: by serializing exactly as is,
* without type decorations. The most common possible use case is that of delegation
* by JSON filter; caller can not know what kind of serializer it gets handed.
*/
@Override
public void serializeWithType(Object value, JsonGenerator gen, SerializerProvider serializers,
TypeSerializer typeSer)
throws IOException
{
gen.writeNull();
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException {
return createSchemaNode("null");
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException {
visitor.expectNullFormat(typeHint);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> foobar() { } }
,B { @Override public void foobar() { } }
;
public abstract void foobar();
}
protected BaseMapTest() { super(); }
/*
/**********************************************************
/* Additional assert methods
/**********************************************************
*/
private final static ObjectMapper SHARED_MAPPER = new ObjectMapper();
protected ObjectMapper objectMapper() {
return SHARED_MAPPER;
}
protected ObjectWriter objectWriter() {
return SHARED_MAPPER.writer();
}
protected ObjectReader objectReader() {
return SHARED_MAPPER.reader();
}
protected ObjectReader objectReader(Class<?> cls) {
return SHARED_MAPPER.reader(cls);
}
/*
/**********************************************************
/* Additional assert methods
/**********************************************************
*/
protected void assertEquals(int[] exp, int[] act)
{
assertArrayEquals(exp, act);
}
/**
* Helper method for verifying 3 basic cookie cutter cases;
* identity comparison (true), and against null (false),
* or object of different type (false)
*/
protected void assertStandardEquals(Object o)
{
assertTrue(o.equals(o));
assertFalse(o.equals(null));
assertFalse(o.equals(SINGLETON_OBJECT));
// just for fun, let's also call hash code...
o.hashCode();
}
/*
/**********************************************************
/* Helper methods, serialization
/**********************************************************
*/
@SuppressWarnings("unchecked")
protected Map<String,Object> writeAndMap(ObjectMapper m, Object value)
throws IOException
{
String str = m.writeValueAsString(value);
return (Map<String,Object>) m.readValue(str, Map.class);
}
protected String serializeAsString(ObjectMapper m, Object value)
throws IOException
{
return m.writeValueAsString(value);
}
protected String serializeAsString(Object value)
throws IOException
{
return serializeAsString(SHARED_MAPPER, value);
}
protected String asJSONObjectValueString(Object... args)
throws IOException
{
return asJSONObjectValueString(SHARED_MAPPER, args);
}
protected String asJSONObjectValueString(ObjectMapper m, Object... args)
throws IOException
{
LinkedHashMap<Object,Object> map = new LinkedHashMap<Object,Object>();
for (int i
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
/**
* Special bogus "serializer" that will throw
* {@link JsonGenerationException} if its {@link #serialize}
* gets invoked. Most commonly registered as handler for unknown types,
* as well as for catching unintended usage (like trying to use null
* as Map/Object key).
*/
@SuppressWarnings("serial")
public class FailingSerializer
extends StdSerializer<Object>
{
protected final String _msg;
public FailingSerializer(String msg) {
super(Object.class);
_msg = msg;
}
@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
throw new JsonGenerationException(_msg);
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) throws JsonMappingException {
return null;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
{
;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
import java.lang.reflect.Array;
import com.fasterxml.jackson.databind.JavaType;
/**
* Array types represent Java arrays, both primitive and object valued.
* Further, Object-valued arrays can have element type of any other
* legal {@link JavaType}.
*/
public final class ArrayType
extends TypeBase
{
private static final long serialVersionUID = 9040058063449087477L;
/**
* Type of elements in the array.
*/
protected final JavaType _componentType;
/**
* We will also keep track of shareable instance of empty array,
* since it usually needs to be constructed any way; and because
* it is essentially immutable and thus can be shared.
*/
protected final Object _emptyArray;
private ArrayType(JavaType componentType, Object emptyInstance,
Object valueHandler, Object typeHandler, boolean asStatic)
{
super(emptyInstance.getClass(), componentType.hashCode(),
valueHandler, typeHandler, asStatic);
_componentType = componentType;
_emptyArray = emptyInstance;
}
public static ArrayType construct(JavaType componentType,
Object valueHandler, Object typeHandler)
{
/* This is bit messy: there is apparently no other way to
* reconstruct actual concrete/raw array class from component
* type, than to construct an instance, get class (same is
* true for GenericArracyType as well; hence we won't bother
* passing that in).
*/
Object emptyInstance = Array.newInstance(componentType.getRawClass(), 0);
return new ArrayType(componentType, emptyInstance, null, null, false);
}
@Override
public ArrayType withTypeHandler(Object h)
{
if (h == _typeHandler) {
return this;
}
return new ArrayType(_componentType, _emptyArray, _valueHandler, h, _asStatic);
}
@Override
public ArrayType withContentTypeHandler(Object h)
{
if (h == _componentType.<Object>getTypeHandler()) {
return this;
}
return new ArrayType(_componentType.withTypeHandler(h), _emptyArray,
_valueHandler, _
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>typeHandler, _asStatic);
}
@Override
public ArrayType withValueHandler(Object h) {
if (h == _valueHandler) {
return this;
}
return new ArrayType(_componentType, _emptyArray, h, _typeHandler,_asStatic);
}
@Override
public ArrayType withContentValueHandler(Object h) {
if (h == _componentType.<Object>getValueHandler()) {
return this;
}
return new ArrayType(_componentType.withValueHandler(h), _emptyArray,
_valueHandler, _typeHandler, _asStatic);
}
@Override
public ArrayType withStaticTyping() {
if (_asStatic) {
return this;
}
return new ArrayType(_componentType.withStaticTyping(),
_emptyArray, _valueHandler, _typeHandler, true);
}
@Override
protected String buildCanonicalName() {
return _class.getName();
}
/*
/**********************************************************
/* Methods for narrowing conversions
/**********************************************************
*/
/**
* Handling of narrowing conversions for arrays is trickier: for now,
* it is not even allowed.
*/
@Override
protected JavaType _narrow(Class<?> subclass)
{
/* Ok: need a bit of indirection here. First, must replace component
* type (and check that it is compatible), then re-construct.
*/
if (!subclass.isArray()) { // sanity check, should never occur
throw new IllegalArgumentException("Incompatible narrowing operation: trying to narrow "+toString()+" to class "+subclass.getName());
}
/* Hmmh. This is an awkward back reference... but seems like the
* only simple way to do it.
*/
Class<?> newCompClass = subclass.getComponentType();
/* 14-Mar-2011, tatu: it gets even worse, as we do not have access to
* currently configured TypeFactory. This could theoretically cause
* problems (when narrowing from array of Objects, to array of non-standard
* Maps, for example); but for now need to defer solving this until
* it actually becomes a real problem, not just potential one.
* (famous last words?)
*/
JavaType newCompType = TypeFactory.defaultInstance().constructType(new
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> }
@Override
public JavaType getContentType() { return _componentType; }
@Override
public int containedTypeCount() { return 1; }
@Override
public JavaType containedType(int index) {
return (index == 0) ? _componentType : null;
}
@Override
public StringBuilder getGenericSignature(StringBuilder sb) {
sb.append('[');
return _componentType.getGenericSignature(sb);
}
@Override
public StringBuilder getErasedSignature(StringBuilder sb) {
sb.append('[');
return _componentType.getErasedSignature(sb);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public String toString()
{
return "[array type, component type: "+_componentType+"]";
}
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
ArrayType other = (ArrayType) o;
return _componentType.equals(other._componentType);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation;
import java.lang.annotation.*;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
/**
* Annotation that can be used to indicate a {@link PropertyNamingStrategy}
* to use for annotated class. Overrides the global (default) strategy.
*
* @since 2.1
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@com.fasterxml.jackson.annotation.JacksonAnnotation
public @interface JsonNaming
{
/**
* @return Type of {@link PropertyNamingStrategy} to use, if any; default value of
* <code>PropertyNamingStrategy.class</code> means "no strategy specified"
* (and may also be used for overriding to remove otherwise applicable
* naming strategy)
*/
public Class<? extends PropertyNamingStrategy> value() default PropertyNamingStrategy.class;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>member = member;
_contextAnnotations = contextAnnotations;
}
@Deprecated // since 2.3
public Std(String name, JavaType type, PropertyName wrapperName,
Annotations contextAnnotations, AnnotatedMember member,
boolean isRequired)
{
this(new PropertyName(name), type, wrapperName, contextAnnotations,
member,
isRequired ? PropertyMetadata.STD_REQUIRED : PropertyMetadata.STD_OPTIONAL);
}
public Std withType(JavaType type) {
return new Std(_name, type, _wrapperName, _contextAnnotations, _member, _metadata);
}
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
return (_member == null) ? null : _member.getAnnotation(acls);
}
@Override
public <A extends Annotation> A getContextAnnotation(Class<A> acls) {
return (_contextAnnotations == null) ? null : _contextAnnotations.get(acls);
}
@Override public String getName() { return _name.getSimpleName(); }
@Override public PropertyName getFullName() { return _name; }
@Override public JavaType getType() { return _type; }
@Override public PropertyName getWrapperName() { return _wrapperName; }
@Override public boolean isRequired() { return _metadata.isRequired(); }
@Override public PropertyMetadata getMetadata() { return _metadata; }
@Override public AnnotatedMember getMember() { return _member; }
/**
*<p>
* TODO: move to {@link BeanProperty} in near future, once all standard
* implementations define it.
*
* @since 2.5
*/
public boolean isVirtual() { return false; }
/**
* Implementation of this method throws
* {@link UnsupportedOperationException}, since instances of this
* implementation should not be used as part of actual structure
* visited. Rather, other implementations should handle it.
*/
@Override
public void depositSchemaProperty(JsonObjectFormatVisitor objectVisitor) {
throw new UnsupportedOperationException("Instances of "+getClass().getName()+" should not get visited");
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> = src._injectableValueId;
_fallbackSetter = src._fallbackSetter;
}
/**
* @since 2.3
*/
protected CreatorProperty(CreatorProperty src, SettableBeanProperty fallbackSetter) {
super(src);
_annotated = src._annotated;
_creatorIndex = src._creatorIndex;
_injectableValueId = src._injectableValueId;
_fallbackSetter = fallbackSetter;
}
@Override
public CreatorProperty withName(PropertyName newName) {
return new CreatorProperty(this, newName);
}
@Override
public CreatorProperty withValueDeserializer(JsonDeserializer<?> deser) {
return new CreatorProperty(this, deser);
}
public CreatorProperty withFallbackSetter(SettableBeanProperty fallbackSetter) {
return new CreatorProperty(this, fallbackSetter);
}
/**
* Method that can be called to locate value to be injected for this
* property, if it is configured for this.
*/
public Object findInjectableValue(DeserializationContext context, Object beanInstance)
{
if (_injectableValueId == null) {
throw new IllegalStateException("Property '"+getName()
+"' (type "+getClass().getName()+") has no injectable value id configured");
}
return context.findInjectableValue(_injectableValueId, this, beanInstance);
}
/**
* Method to find value to inject, and inject it to this property.
*/
public void inject(DeserializationContext context, Object beanInstance)
throws IOException
{
set(beanInstance, findInjectableValue(context, beanInstance));
}
/*
/**********************************************************
/* BeanProperty impl
/**********************************************************
*/
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls) {
if (_annotated == null) {
return null;
}
return _annotated.getAnnotation(acls);
}
@Override public AnnotatedMember getMember() { return _annotated; }
@Override public int getCreatorIndex() {
return _creatorIndex;
}
/*
/**********************************************************
/* Overridden methods
/**********************************************************
*/
@Override
public void deserializeAndSet(JsonParser jp, DeserializationContext ctxt,
Object instance)
throws IOException, JsonProcessingException
{
set(instance, deserialize(jp, ctxt));
}
@Override
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> public Object deserializeSetAndReturn(JsonParser jp,
DeserializationContext ctxt, Object instance)
throws IOException, JsonProcessingException
{
return setAndReturn(instance, deserialize(jp, ctxt));
}
@Override
public void set(Object instance, Object value) throws IOException
{
/* Hmmmh. Should we return quietly (NOP), or error?
* Perhaps better to throw an exception, since it's generally an error.
*/
if (_fallbackSetter == null) {
throw new IllegalStateException("No fallback setter/field defined: can not use creator property for "
+getClass().getName());
}
_fallbackSetter.set(instance, value);
}
@Override
public Object setAndReturn(Object instance, Object value) throws IOException
{
if (_fallbackSetter == null) {
throw new IllegalStateException("No fallback setter/field defined: can not use creator property for "
+getClass().getName());
}
return _fallbackSetter.setAndReturn(instance, value);
}
@Override
public Object getInjectableValueId() {
return _injectableValueId;
}
@Override
public String toString() { return "[creator property, name '"+getName()+"'; inject id '"+_injectableValueId+"']"; }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> annotated, implClass);
if (gen == null) {
gen = (ObjectIdGenerator<?>) ClassUtil.createInstance(implClass,
config.canOverrideAccessModifiers());
}
return gen.forScope(objectIdInfo.getScope());
}
public ObjectIdResolver objectIdResolverInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
{
Class<? extends ObjectIdResolver> implClass = objectIdInfo.getResolverType();
final MapperConfig<?> config = getConfig();
HandlerInstantiator hi = config.getHandlerInstantiator();
ObjectIdResolver resolver = (hi == null) ? null : hi.resolverIdGeneratorInstance(config, annotated, implClass);
if (resolver == null) {
resolver = ClassUtil.createInstance(implClass, config.canOverrideAccessModifiers());
}
return resolver;
}
/**
* Helper method to use to construct a {@link Converter}, given a definition
* that may be either actual converter instance, or Class for instantiating one.
*
* @since 2.2
*/
@SuppressWarnings("unchecked")
public Converter<Object,Object> converterInstance(Annotated annotated,
Object converterDef)
throws JsonMappingException
{
if (converterDef == null) {
return null;
}
if (converterDef instanceof Converter<?,?>) {
return (Converter<Object,Object>) converterDef;
}
if (!(converterDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned Converter definition of type "
+converterDef.getClass().getName()+"; expected type Converter or Class<Converter> instead");
}
Class<?> converterClass = (Class<?>)converterDef;
// there are some known "no class" markers to consider too:
if (converterClass == Converter.None.class || ClassUtil.isBogusClass(converterClass)) {
return null;
}
if (!Converter.class.isAssignableFrom(converterClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "
+converterClass.getName()+"; expected Class<Converter>");
}
final MapperConfig<?> config = getConfig();
HandlerInstantiator hi = config.getHandlerInstantiator();
Converter<?,?> conv = (hi == null) ? null : hi.converterInstance(config, annotated, converterClass);
if (conv == null) {
conv = (Converter<?,?>) ClassUtil.create
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
/**
* Simple general purpose serializer, useful for any
* type for which {@link Object#toString} returns the desired JSON
* value.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class ToStringSerializer
extends StdSerializer<Object>
{
/**
* Singleton instance to use.
*/
public final static ToStringSerializer instance = new ToStringSerializer();
/**
*<p>
* Note: usually you should NOT create new instances, but instead use
* {@link #instance} which is stateless and fully thread-safe. However,
* there are cases where constructor is needed; for example,
* when using explicit serializer annotations like
* {@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using}.
*/
public ToStringSerializer() { super(Object.class); }
/**
* Sometimes it may actually make sense to retain actual handled type, so...
*
* @since 2.5
*/
public ToStringSerializer(Class<?> handledType) {
super(handledType, false);
}
@Override
@Deprecated
public boolean isEmpty(Object value) {
return isEmpty(null, value);
}
@Override
public boolean isEmpty(SerializerProvider prov, Object value) {
if (value == null) {
return true;
}
String str = value.toString();
return str.isEmpty();
}
@Override
public void serialize(Object value, JsonGenerator gen, SerializerProvider provider)
throws IOException
{
gen.writeString(value.toString());
}
/* 01-Mar-2011, tatu: We were serializing as "raw" String; but
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> super(Object[].class, null);
_elementType = elemType;
_staticTyping = staticTyping;
_valueTypeSerializer = vts;
_dynamicSerializers = PropertySerializerMap.emptyForProperties();
_elementSerializer = elementSerializer;
}
public ObjectArraySerializer(ObjectArraySerializer src, TypeSerializer vts)
{
super(src);
_elementType = src._elementType;
_valueTypeSerializer = vts;
_staticTyping = src._staticTyping;
_dynamicSerializers = src._dynamicSerializers;
_elementSerializer = src._elementSerializer;
}
@SuppressWarnings("unchecked")
public ObjectArraySerializer(ObjectArraySerializer src,
BeanProperty property, TypeSerializer vts, JsonSerializer<?> elementSerializer)
{
super(src, property);
_elementType = src._elementType;
_valueTypeSerializer = vts;
_staticTyping = src._staticTyping;
_dynamicSerializers = src._dynamicSerializers;
_elementSerializer = (JsonSerializer<Object>) elementSerializer;
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts)
{
return new ObjectArraySerializer(_elementType, _staticTyping, vts, _elementSerializer);
}
public ObjectArraySerializer withResolved(BeanProperty prop,
TypeSerializer vts, JsonSerializer<?> ser) {
if (_property == prop && ser == _elementSerializer && _valueTypeSerializer == vts) {
return this;
}
return new ObjectArraySerializer(this, prop, vts, ser);
}
/*
/**********************************************************
/* Post-processing
/**********************************************************
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property)
throws JsonMappingException
{
TypeSerializer vts = _valueTypeSerializer;
if (vts != null) {
vts = vts.forProperty(property);
}
/* 29-Sep-2012, tatu: Actually, we need to do much more contextual
* checking here since we finally know for sure the property,
* and it may have overrides
*/
JsonSerializer<?> ser = null;
// First: if we have a property, may have property-annotation overrides
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (_elementSerializer != null) {
serializeContentsUsing(value, jgen, provider, _elementSerializer);
return;
}
if (_valueTypeSerializer != null) {
serializeTypedContents(value, jgen, provider);
return;
}
int i = 0;
Object elem = null;
try {
PropertySerializerMap serializers = _dynamicSerializers;
for (; i < len; ++i) {
elem = value[i];
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
// To fix [JACKSON-508]
if (_elementType.hasGenericTypes()) {
serializer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_elementType, cc), provider);
} else {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
}
serializer.serialize(elem, jgen, provider);
}
} catch (IOException ioe) {
throw ioe;
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
/* 05-Mar-2009, tatu: But one nasty edge is when we get
* StackOverflow: usually due to infinite loop. But that gets
* hidden within an InvocationTargetException...
*/
Throwable t = e;
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) {
throw (Error) t;
}
throw JsonMappingException.wrapWithPath(t, elem, i);
}
}
public void serializeContentsUsing(Object[] value, JsonGenerator jgen, SerializerProvider provider,
JsonSerializer<Object> ser) throws IOException
{
final int len = value.length;
final TypeSerializer typeSer = _valueTypeSerializer;
int i = 0;
Object elem = null;
try {
for (; i < len; ++i) {
elem = value[i];
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
if (type
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Ser == null) {
ser.serialize(elem, jgen, provider);
} else {
ser.serializeWithType(elem, jgen, provider, typeSer);
}
}
} catch (IOException ioe) {
throw ioe;
} catch (Exception e) {
Throwable t = e;
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) {
throw (Error) t;
}
throw JsonMappingException.wrapWithPath(t, elem, i);
}
}
public void serializeTypedContents(Object[] value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.length;
final TypeSerializer typeSer = _valueTypeSerializer;
int i = 0;
Object elem = null;
try {
PropertySerializerMap serializers = _dynamicSerializers;
for (; i < len; ++i) {
elem = value[i];
if (elem == null) {
provider.defaultSerializeNull(jgen);
continue;
}
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializer.serializeWithType(elem, jgen, provider, typeSer);
}
} catch (IOException ioe) {
throw ioe;
} catch (Exception e) {
Throwable t = e;
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
if (t instanceof Error) {
throw (Error) t;
}
throw JsonMappingException.wrapWithPath(t, elem, i);
}
}
@SuppressWarnings("deprecation")
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
ObjectNode o = createSchemaNode("array", true);
if (typeHint != null) {
JavaType javaType = provider.constructType(typeHint);
if (javaType.isArrayType()) {
Class<?> componentType = ((ArrayType) javaType).getContentType().getRawClass();
// 15-Oct-2010
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped?
if (componentType == Object.class) {
o.put("items", com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode());
} else {
JsonSerializer<Object> ser = provider.findValueSerializer(componentType, _property);
JsonNode schemaNode = (ser instanceof SchemaAware) ?
((SchemaAware) ser).getSchema(provider, null) :
com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode();
o.put("items", schemaNode);
}
}
}
return o;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonArrayFormatVisitor arrayVisitor = visitor.expectArrayFormat(typeHint);
if (arrayVisitor != null) {
TypeFactory tf = visitor.getProvider().getTypeFactory();
JavaType contentType = tf.moreSpecificType(_elementType, typeHint.getContentType());
if (contentType == null) {
throw new JsonMappingException("Could not resolve type");
}
JsonSerializer<?> valueSer = _elementSerializer;
if (valueSer == null) {
valueSer = visitor.getProvider().findValueSerializer(contentType, _property);
}
arrayVisitor.itemsFormat(valueSer, contentType);
}
}
protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
Class<?> type, SerializerProvider provider) throws JsonMappingException
{
PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSecondarySerializer(type, provider, _property);
// did we get a new map of serializers? If so, start using it
if (map != result.map) {
_dynamicSerializers = result.map;
}
return result.serializer;
}
protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
JavaType type, SerializerProvider provider) throws JsonMappingException
{
PropertySerializerMap.SerializerAndMapResult result = map.findAndAddSecondarySerializer(type, provider, _property);
// did we get a new map of serializers? If so, start using it
if (map != result.map) {
_dynamic
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import java.util.Map;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonNumberFormatVisitor;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
/**
* Container class for serializers used for handling standard JDK-provided types.
*/
@SuppressWarnings("serial")
public class NumberSerializers
{
protected NumberSerializers() { }
public static void addAll(Map<String, JsonSerializer<?>> allDeserializers)
{
final JsonSerializer<?> intS = new IntegerSerializer();
allDeserializers.put(Integer.class.getName(), intS);
allDeserializers.put(Integer.TYPE.getName(), intS);
allDeserializers.put(Long.class.getName(), LongSerializer.instance);
allDeserializers.put(Long.TYPE.getName(), LongSerializer.instance);
allDeserializers.put(Byte.class.getName(), IntLikeSerializer.instance);
allDeserializers.put(Byte.TYPE.getName(), IntLikeSerializer.instance);
allDeserializers.put(Short.class.getName(), ShortSerializer.instance);
allDeserializers.put(Short.TYPE.getName(), ShortSerializer.instance);
// Numbers, limited length floating point
allDeserializers.put(Float.class.getName(), FloatSerializer.instance);
allDeserializers.put(Float.TYPE.getName(), FloatSerializer.instance);
allDeserializers.put(Double.class.getName(), DoubleSerializer.instance);
allDeserializers.put(Double.TYPE.getName(), DoubleSerializer.instance);
}
/*
/**********************************************************
/* Shared base class
/**********************************************************
*/
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
protected abstract static class Base<T> extends StdScalarSerializer<T>
implements ContextualSerializer
{
protected final JsonParser.NumberType _numberType;
protected final String _schemaType;
protected final boolean _isInt;
protected Base(Class<T> cls, JsonParser.NumberType numberType, String schemaType) {
super(cls);
_numberType = numberType;
_schemaType = schemaType;
_isInt = (numberType == JsonParser.NumberType.INT)
|| (numberType == JsonParser.NumberType.LONG)
|| (numberType == JsonParser.NumberType.BIG_INTEGER)
;
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode(_schemaType, true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
if (_isInt) {
JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint);
if (v2 != null) {
v2.numberType(_numberType);
}
} else {
JsonNumberFormatVisitor v2 = visitor.expectNumberFormat(typeHint);
if (v2 != null) {
v2.numberType(_numberType);
}
}
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider prov,
BeanProperty property) throws JsonMappingException
{
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null) {
JsonFormat.Value format = prov.getAnnotationIntrospector().findFormat(m);
if (format != null) {
switch (format.getShape()) {
case STRING:
return ToStringSerializer.instance;
default:
}
}
}
}
return this;
}
}
/*
/**********************************************************
/* Concrete serializers, numerics
/**********************************************************
*/
@JacksonStdImpl
public final static class ShortSerializer extends Base<Short>
{
final static ShortSerializer instance = new ShortSerializer();
public ShortSerializer() { super(Short.class, JsonParser.NumberType.INT, "number"); }
@Override
public void serialize(Short value, JsonGenerator jgen, SerializerProvider provider) throws IOException
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> {
jgen.writeNumber(value.shortValue());
}
}
/**
* This is the special serializer for regular {@link java.lang.Integer}s
* (and primitive ints)
*<p>
* Since this is one of "native" types, no type information is ever
* included on serialization (unlike for most scalar types as of 1.5)
*/
@JacksonStdImpl
public final static class IntegerSerializer extends Base<Integer>
{
public IntegerSerializer() { super(Integer.class, JsonParser.NumberType.INT ,"integer"); }
@Override
public void serialize(Integer value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeNumber(value.intValue());
}
// IMPORTANT: copied from `NonTypedScalarSerializerBase`
@Override
public void serializeWithType(Integer value, JsonGenerator jgen,
SerializerProvider provider, TypeSerializer typeSer) throws IOException {
// no type info, just regular serialization
serialize(value, jgen, provider);
}
}
/**
* Similar to {@link IntegerSerializer}, but will not cast to Integer:
* instead, cast is to {@link java.lang.Number}, and conversion is
* by calling {@link java.lang.Number#intValue}.
*/
@JacksonStdImpl
public final static class IntLikeSerializer extends Base<Number>
{
final static IntLikeSerializer instance = new IntLikeSerializer();
public IntLikeSerializer() {
super(Number.class, JsonParser.NumberType.INT, "integer");
}
@Override
public void serialize(Number value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeNumber(value.intValue());
}
}
@JacksonStdImpl
public final static class LongSerializer extends Base<Long>
{
final static LongSerializer instance = new LongSerializer();
public LongSerializer() { super(Long.class, JsonParser.NumberType.LONG, "number"); }
@Override
public void serialize(Long value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeNumber(value.longValue());
}
}
@JacksonStdImpl
public final static class FloatSerializer extends Base<Float>
{
final static FloatSerializer instance = new FloatSerializer();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
public FloatSerializer() { super(Float.class, JsonParser.NumberType.FLOAT, "number"); }
@Override
public void serialize(Float value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeNumber(value.floatValue());
}
}
/**
* This is the special serializer for regular {@link java.lang.Double}s
* (and primitive doubles)
*<p>
* Since this is one of "native" types, no type information is ever
* included on serialization (unlike for most scalar types as of 1.5)
*/
@JacksonStdImpl
public final static class DoubleSerializer extends Base<Double>
{
final static DoubleSerializer instance = new DoubleSerializer();
public DoubleSerializer() { super(Double.class, JsonParser.NumberType.DOUBLE, "number"); }
@Override
public void serialize(Double value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeNumber(value.doubleValue());
}
// IMPORTANT: copied from `NonTypedScalarSerializerBase`
@Override
public void serializeWithType(Double value, JsonGenerator jgen,
SerializerProvider provider, TypeSerializer typeSer) throws IOException {
// no type info, just regular serialization
serialize(value, jgen, provider);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.KeyDeserializer;
import com.fasterxml.jackson.databind.util.Converter;
/**
* Annotation use for configuring deserialization aspects, by attaching
* to "setter" methods or fields, or to value classes.
* When annotating value classes, configuration is used for instances
* of the value class but can be overridden by more specific annotations
* (ones that attach to methods or fields).
*<p>
* An example annotation would be:
*<pre>
* @JsonDeserialize(using=MySerializer.class,
* as=MyHashMap.class,
* keyAs=MyHashKey.class,
* contentAs=MyHashValue.class
* )
*</pre>
*<p>
*/
@Target({ElementType.ANNOTATION_TYPE, ElementType.METHOD, ElementType.FIELD, ElementType.TYPE, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@com.fasterxml.jackson.annotation.JacksonAnnotation
public @interface JsonDeserialize
{
// // // Annotations for explicitly specifying deserialize/builder
/**
* Deserializer class to use for deserializing associated value.
* Depending on what is annotated,
* value is either an instance of annotated class (used globablly
* anywhere where class deserializer is needed); or only used for
* deserializing property access via a setter method.
*/
public Class<? extends JsonDeserializer<?>> using()
default JsonDeserializer.None.class;
/**
* Deserializer class to use for deserializing contents (elements
* of a Collection/array, values of Maps) of annotated property.
* Can only be used on instances (methods, fields, constructors),
* and not value classes themselves.
*/
public Class<? extends JsonDeserializer<?>> contentUsing()
default JsonDeserializer.None.class;
/**
* Deserializer class to use for deserializing Map keys
* of annotated property.
* Can only be used on instances (methods, fields, constructors),
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * and not value classes themselves.
*/
public Class<? extends KeyDeserializer> keyUsing()
default KeyDeserializer.None.class;
/**
* Annotation for specifying if an external Builder class is to
* be used for building up deserialized instances of annotated
* class. If so, an instance of referenced class is first constructed
* (possibly using a Creator method; or if none defined, using default
* constructor), and its "with-methods" are used for populating fields;
* and finally "build-method" is invoked to complete deserialization.
*/
public Class<?> builder() default Void.class;
// // // Annotations for specifying intermediate Converters (2.2+)
/**
* Which helper object (if any) is to be used to convert from Jackson-bound
* intermediate type (source type of converter) into actual property type
* (which must be same as result type of converter). This is often used
* for two-step deserialization; Jackson binds data into suitable intermediate
* type (like Tree representation), and converter then builds actual property
* type.
*
* @since 2.2
*/
public Class<? extends Converter<?,?>> converter() default Converter.None.class;
/**
* Similar to {@link #converter}, but used for values of structures types
* (List, arrays, Maps).
*
* @since 2.2
*/
public Class<? extends Converter<?,?>> contentConverter() default Converter.None.class;
// // // Annotations for explicitly specifying deserialization type
// // // (which is used for choosing deserializer, if not explicitly
// // // specified
/**
* Concrete type to deserialize values as, instead of type otherwise
* declared. Must be a subtype of declared type; otherwise an
* exception may be thrown by deserializer.
*<p>
* Bogus type {@link Void} can be used to indicate that declared
* type is used as is (i.e. this annotation property has no setting);
* this since annotation properties are not allowed to have null value.
*<p>
* Note: if {@link #using} is also used it has precedence
* (since it directly specified
* deserializer, whereas this would only be used to locate the
* deserializer)
* and value of this annotation property is ignored.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
*/
public Class<?> as() default Void.class;
/**
* Concrete type to deserialize keys of {@link java.util.Map} as,
* instead of type otherwise declared.
* Must be a subtype of declared type; otherwise an exception may be
* thrown by deserializer.
*/
public Class<?> keyAs() default Void.class;
/**
* Concrete type to deserialize content (elements
* of a Collection/array, values of Maps) values as,
* instead of type otherwise declared.
* Must be a subtype of declared type; otherwise an exception may be
* thrown by deserializer.
*/
public Class<?> contentAs() default Void.class;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.util.TokenBuffer;
/**
* We also want to directly support deserialization of {@link TokenBuffer}.
*<p>
* Note that we use scalar deserializer base just because we claim
* to be of scalar for type information inclusion purposes; actual
* underlying content can be of any (Object, Array, scalar) type.
*<p>
* Since 2.3, another important thing is that possible native ids
* (type id, object id) should be properly copied even when converting
* with {@link TokenBuffer}. Such ids are supported if (and only if!)
* source {@link JsonParser} supports them.
*/
@JacksonStdImpl
public class TokenBufferDeserializer extends StdScalarDeserializer<TokenBuffer> {
private static final long serialVersionUID = 1L;
public TokenBufferDeserializer() { super(TokenBuffer.class); }
@Override
public TokenBuffer deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException {
return createBufferInstance(jp).deserialize(jp, ctxt);
}
protected TokenBuffer createBufferInstance(JsonParser jp) {
return new TokenBuffer(jp);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.type;
/**
* Key class, used as an efficient and accurate key
* for locating per-class values, such as
* {@link com.fasterxml.jackson.databind.JsonSerializer}s.
*<p>
* The reason for having a separate key class instead of
* directly using {@link Class} as key is mostly
* to allow for redefining <code>hashCode</code> method --
* for some strange reason, {@link Class} does not
* redefine {@link Object#hashCode} and thus uses identity
* hash, which is pretty slow. This makes key access using
* {@link Class} unnecessarily slow.
*<p>
* Note: since class is not strictly immutable, caller must
* know what it is doing, if changing field values.
*/
public final class ClassKey
implements Comparable<ClassKey>,
java.io.Serializable // since 2.1
{
private static final long serialVersionUID = 1L;
private String _className;
private Class<?> _class;
/**
* Let's cache hash code straight away, since we are
* almost certain to need it.
*/
private int _hashCode;
public ClassKey()
{
_class = null;
_className = null;
_hashCode = 0;
}
public ClassKey(Class<?> clz)
{
_class = clz;
_className = clz.getName();
_hashCode = _className.hashCode();
}
public void reset(Class<?> clz)
{
_class = clz;
_className = clz.getName();
_hashCode = _className.hashCode();
}
/*
/**********************************************************
/* Comparable
/**********************************************************
*/
@Override
public int compareTo(ClassKey other)
{
// Just need to sort by name, ok to collide (unless used in TreeMap/Set!)
return _className.compareTo(other._className);
}
/*
/**********************************************************
/* Standard methods
/**********************************************************
*/
@Override
public boolean equals(Object o)
{
if (o == this) return true;
if (o == null) return false;
if (o.getClass() != getClass()) return false;
ClassKey other = (ClassKey)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> o;
/* Is it possible to have different Class object for same name + class loader combo?
* Let's assume answer is no: if this is wrong, will need to uncomment following functionality
*/
/*
return (other._className.equals(_className))
&& (other._class.getClassLoader() == _class.getClassLoader());
*/
return other._class == _class;
}
@Override public int hashCode() { return _hashCode; }
@Override public String toString() { return _className; }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>**
*/
protected JsonDeserializer<Object> _mapDeserializer;
protected JsonDeserializer<Object> _listDeserializer;
protected JsonDeserializer<Object> _stringDeserializer;
protected JsonDeserializer<Object> _numberDeserializer;
public UntypedObjectDeserializer() {
super(Object.class);
}
@SuppressWarnings("unchecked")
public UntypedObjectDeserializer(UntypedObjectDeserializer base,
JsonDeserializer<?> mapDeser, JsonDeserializer<?> listDeser,
JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser)
{
super(Object.class);
_mapDeserializer = (JsonDeserializer<Object>) mapDeser;
_listDeserializer = (JsonDeserializer<Object>) listDeser;
_stringDeserializer = (JsonDeserializer<Object>) stringDeser;
_numberDeserializer = (JsonDeserializer<Object>) numberDeser;
}
/*
/**********************************************************
/* Initialization
/**********************************************************
*/
/**
* We need to implement this method to properly find things to delegate
* to: it can not be done earlier since delegated deserializers almost
* certainly require access to this instance (at least "List" and "Map" ones)
*/
@SuppressWarnings("unchecked")
@Override
public void resolve(DeserializationContext ctxt) throws JsonMappingException
{
JavaType obType = ctxt.constructType(Object.class);
JavaType stringType = ctxt.constructType(String.class);
TypeFactory tf = ctxt.getTypeFactory();
/* 26-Nov-2014, tatu: This is highly unusual, as in general contextualization
* should always be called separately, from within "createContextual()".
* But this is a very singular deserializer since it operates on `Object`
* (and often for `?` type parameter), and as a result, easily and commonly
* results in cycles, being value deserializer for various Maps and Collections.
* Because of this, we must somehow break the cycles. This is done here by
* forcing pseudo-contextualization with null property.
*/
// So: first find possible custom instances
_mapDeserializer = _findCustomDeser(ctxt, tf.constructMapType(Map.class, stringType, obType));
_listDeserializer = _findCustomDeser(ctxt, tf.constructCollectionType(
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>List.class, obType));
_stringDeserializer = _findCustomDeser(ctxt, stringType);
_numberDeserializer = _findCustomDeser(ctxt, tf.constructType(Number.class));
// and then do bogus contextualization, in case custom ones need to resolve dependencies of
// their own
JavaType unknown = TypeFactory.unknownType();
_mapDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_mapDeserializer, null, unknown);
_listDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_listDeserializer, null, unknown);
_stringDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_stringDeserializer, null, unknown);
_numberDeserializer = (JsonDeserializer<Object>) ctxt.handleSecondaryContextualization(_numberDeserializer, null, unknown);
}
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> _findCustomDeser(DeserializationContext ctxt, JavaType type)
throws JsonMappingException
{
// Since we are calling from `resolve`, we should NOT try to contextualize yet;
// contextualization will only occur at a later point
JsonDeserializer<?> deser = ctxt.findNonContextualValueDeserializer(type);
if (ClassUtil.isJacksonStdImpl(deser)) {
return null;
}
return (JsonDeserializer<Object>) deser;
}
/**
* We only use contextualization for optimizing the case where no customization
* occurred; if so, can slip in a more streamlined version.
*/
@Override
public JsonDeserializer<?> createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
// 20-Apr-2014, tatu: If nothing custom, let's use "vanilla" instance,
// simpler and can avoid some of delegation
if ((_stringDeserializer == null) && (_numberDeserializer == null)
&& (_mapDeserializer == null) && (_listDeserializer == null)
&& getClass() == UntypedObjectDeserializer.class) {
return Vanilla.std;
}
return this;
}
protected JsonDeserializer<?> _withResolved(JsonDeserializer<?> mapDeser,
JsonDeserializer<?> listDeser,
JsonDeserializer<?> stringDeser, JsonDeserializer<?> numberDeser) {
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> optimal, whatever it is
case VALUE_NUMBER_FLOAT:
if (_numberDeserializer != null) {
return _numberDeserializer.deserialize(jp, ctxt);
}
/* [JACKSON-72]: need to allow overriding the behavior regarding
* which type to use
*/
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
return jp.getDecimalValue();
}
return Double.valueOf(jp.getDoubleValue());
case VALUE_TRUE:
return Boolean.TRUE;
case VALUE_FALSE:
return Boolean.FALSE;
case VALUE_NULL: // should not get this but...
return null;
case END_ARRAY: // invalid
case END_OBJECT: // invalid
default:
throw ctxt.mappingException(Object.class);
}
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException
{
JsonToken t = jp.getCurrentToken();
switch (t) {
// First: does it look like we had type id wrapping of some kind?
case START_ARRAY:
case START_OBJECT:
case FIELD_NAME:
/* Output can be as JSON Object, Array or scalar: no way to know
* a this point:
*/
return typeDeserializer.deserializeTypedFromAny(jp, ctxt);
/* Otherwise we probably got a "native" type (ones that map
* naturally and thus do not need or use type ids)
*/
case VALUE_STRING:
if (_stringDeserializer != null) {
return _stringDeserializer.deserialize(jp, ctxt);
}
return jp.getText();
case VALUE_NUMBER_INT:
if (_numberDeserializer != null) {
return _numberDeserializer.deserialize(jp, ctxt);
}
// For [JACKSON-100], see above:
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
return jp.getBigIntegerValue();
}
/* and as per [JACKSON-839], allow "upgrade" to bigger types: out-of-range
* entries can not be produced without type, so this should "just work",
* even if it is bit unclean
*/
return jp.getNumberValue();
case VALUE_NUMBER
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>_FLOAT:
if (_numberDeserializer != null) {
return _numberDeserializer.deserialize(jp, ctxt);
}
// For [JACKSON-72], see above
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
return jp.getDecimalValue();
}
return Double.valueOf(jp.getDoubleValue());
case VALUE_TRUE:
return Boolean.TRUE;
case VALUE_FALSE:
return Boolean.FALSE;
case VALUE_EMBEDDED_OBJECT:
return jp.getEmbeddedObject();
case VALUE_NULL: // should not get this far really but...
return null;
default:
throw ctxt.mappingException(Object.class);
}
}
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
/**
* Method called to map a JSON Array into a Java value.
*/
protected Object mapArray(JsonParser jp, DeserializationContext ctxt) throws IOException
{
// Minor optimization to handle small lists (default size for ArrayList is 10)
if (jp.nextToken() == JsonToken.END_ARRAY) {
return new ArrayList<Object>(2);
}
Object value = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_ARRAY) {
ArrayList<Object> l = new ArrayList<Object>(2);
l.add(value);
return l;
}
Object value2 = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_ARRAY) {
ArrayList<Object> l = new ArrayList<Object>(2);
l.add(value);
l.add(value2);
return l;
}
ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] values = buffer.resetAndStart();
int ptr = 0;
values[ptr++] = value;
values[ptr++] = value2;
int totalSize = ptr;
do {
value = deserialize(jp, ctxt);
++totalSize;
if (ptr >= values.length) {
values = buffer.appendCompletedChunk(values);
ptr = 0;
}
values[ptr++] = value;
} while (jp.nextToken() != JsonToken.END_ARRAY);
// let's create full array then
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>0)
if (jp.nextToken() == JsonToken.END_ARRAY) {
return NO_OBJECTS;
}
ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] values = buffer.resetAndStart();
int ptr = 0;
do {
Object value = deserialize(jp, ctxt);
if (ptr >= values.length) {
values = buffer.appendCompletedChunk(values);
ptr = 0;
}
values[ptr++] = value;
} while (jp.nextToken() != JsonToken.END_ARRAY);
return buffer.completeAndClearBuffer(values, ptr);
}
/*
/**********************************************************
/* Separate "vanilla" implementation for common case of
/* no custom deserializer overrides
/**********************************************************
*/
@JacksonStdImpl
public static class Vanilla
extends StdDeserializer<Object>
{
private static final long serialVersionUID = 1L;
public final static Vanilla std = new Vanilla();
public Vanilla() { super(Object.class); }
@Override
public Object deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
switch (jp.getCurrentTokenId()) {
case JsonTokenId.ID_START_OBJECT:
{
JsonToken t = jp.nextToken();
if (t == JsonToken.END_OBJECT) {
return new LinkedHashMap<String,Object>(2);
}
}
case JsonTokenId.ID_FIELD_NAME:
return mapObject(jp, ctxt);
case JsonTokenId.ID_START_ARRAY:
{
JsonToken t = jp.nextToken();
if (t == JsonToken.END_ARRAY) { // and empty one too
if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
return NO_OBJECTS;
}
return new ArrayList<Object>(2);
}
}
if (ctxt.isEnabled(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY)) {
return mapArrayToArray(jp, ctxt);
}
return mapArray(jp, ctxt);
case JsonTokenId.ID_EMBEDDED_OBJECT:
return jp.getEmbeddedObject();
case JsonTokenId.ID_STRING:
return jp.getText();
case JsonTokenId.ID_NUMBER_INT:
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
return jp.getBigIntegerValue(); // should be optimal, whatever it is
}
return jp.getNumberValue(); // should be optimal, whatever it is
case JsonTokenId.ID_NUMBER_FLOAT:
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
return jp.getDecimalValue();
}
return Double.valueOf(jp.getDoubleValue());
case JsonTokenId.ID_TRUE:
return Boolean.TRUE;
case JsonTokenId.ID_FALSE:
return Boolean.FALSE;
case JsonTokenId.ID_NULL: // should not get this but...
return null;
//case JsonTokenId.ID_END_ARRAY: // invalid
//case JsonTokenId.ID_END_OBJECT: // invalid
default:
throw ctxt.mappingException(Object.class);
}
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt, TypeDeserializer typeDeserializer) throws IOException
{
switch (jp.getCurrentTokenId()) {
case JsonTokenId.ID_START_ARRAY:
case JsonTokenId.ID_START_OBJECT:
case JsonTokenId.ID_FIELD_NAME:
return typeDeserializer.deserializeTypedFromAny(jp, ctxt);
case JsonTokenId.ID_STRING:
return jp.getText();
case JsonTokenId.ID_NUMBER_INT:
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_INTEGER_FOR_INTS)) {
return jp.getBigIntegerValue();
}
return jp.getNumberValue();
case JsonTokenId.ID_NUMBER_FLOAT:
if (ctxt.isEnabled(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS)) {
return jp.getDecimalValue();
}
return Double.valueOf(jp.getDoubleValue());
case JsonTokenId.ID_TRUE:
return Boolean.TRUE;
case JsonTokenId.ID_FALSE:
return Boolean.FALSE;
case JsonTokenId.ID_EMBEDDED_OBJECT:
return jp.getEmbeddedObject();
case JsonTokenId.ID_NULL: // should not get this far really but...
return null;
default:
throw ctxt.mappingException(Object.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>class);
}
}
protected Object mapArray(JsonParser jp, DeserializationContext ctxt) throws IOException
{
Object value = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_ARRAY) {
ArrayList<Object> l = new ArrayList<Object>(2);
l.add(value);
return l;
}
Object value2 = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_ARRAY) {
ArrayList<Object> l = new ArrayList<Object>(2);
l.add(value);
l.add(value2);
return l;
}
ObjectBuffer buffer = ctxt.leaseObjectBuffer();
Object[] values = buffer.resetAndStart();
int ptr = 0;
values[ptr++] = value;
values[ptr++] = value2;
int totalSize = ptr;
do {
value = deserialize(jp, ctxt);
++totalSize;
if (ptr >= values.length) {
values = buffer.appendCompletedChunk(values);
ptr = 0;
}
values[ptr++] = value;
} while (jp.nextToken() != JsonToken.END_ARRAY);
// let's create full array then
ArrayList<Object> result = new ArrayList<Object>(totalSize);
buffer.completeAndClearBuffer(values, ptr, result);
return result;
}
/**
* Method called to map a JSON Object into a Java value.
*/
protected Object mapObject(JsonParser jp, DeserializationContext ctxt) throws IOException
{
// will point to FIELD_NAME at this point, guaranteed
String field1 = jp.getText();
jp.nextToken();
Object value1 = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_OBJECT) { // single entry; but we want modifiable
LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(2);
result.put(field1, value1);
return result;
}
String field2 = jp.getText();
jp.nextToken();
Object value2 = deserialize(jp, ctxt);
if (jp.nextToken() == JsonToken.END_OBJECT) {
LinkedHashMap<String, Object> result = new LinkedHashMap<String, Object>(4);
result.put(field1
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.impl;
import com.fasterxml.jackson.annotation.ObjectIdGenerator;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
// Simple placeholder
public class PropertyBasedObjectIdGenerator
extends ObjectIdGenerators.PropertyGenerator
{
private static final long serialVersionUID = 1L;
public PropertyBasedObjectIdGenerator(Class<?> scope) {
super(scope);
}
@Override
public Object generateId(Object forPojo) {
throw new UnsupportedOperationException();
}
@Override
public ObjectIdGenerator<Object> forScope(Class<?> scope) {
return (scope == _scope) ? this : new PropertyBasedObjectIdGenerator(scope);
}
@Override
public ObjectIdGenerator<Object> newForSerialization(Object context) {
return this;
}
@Override
public com.fasterxml.jackson.annotation.ObjectIdGenerator.IdKey key(Object key) {
if (key == null) {
return null;
}
// should we use general type for all; or type of property itself?
return new IdKey(getClass(), _scope, key);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import com.fasterxml.jackson.annotation.ObjectIdGenerator;
import com.fasterxml.jackson.annotation.ObjectIdGenerators;
import com.fasterxml.jackson.databind.introspect.ObjectIdInfo;
import com.fasterxml.jackson.databind.ser.*;
public class PropertyBasedObjectIdGenerator
extends ObjectIdGenerators.PropertyGenerator
{
private static final long serialVersionUID = 1L;
protected final BeanPropertyWriter _property;
public PropertyBasedObjectIdGenerator(ObjectIdInfo oid, BeanPropertyWriter prop)
{
this(oid.getScope(), prop);
}
protected PropertyBasedObjectIdGenerator(Class<?> scope, BeanPropertyWriter prop)
{
super(scope);
_property = prop;
}
/**
* We must override this method, to prevent errors when scopes are the same,
* but underlying class (on which to access property) is different.
*/
@Override
public boolean canUseFor(ObjectIdGenerator<?> gen) {
if (gen.getClass() == getClass()) {
PropertyBasedObjectIdGenerator other = (PropertyBasedObjectIdGenerator) gen;
if (other.getScope() == _scope) {
/* 26-Jul-2012, tatu: This is actually not enough, because the property
* accessor within BeanPropertyWriter won't work for other property fields
* (see [https://github.com/FasterXML/jackson-module-jaxb-annotations/issues/9]
* for details).
* So we need to verify that underlying property is actually the same.
*/
return (other._property == _property);
}
}
return false;
}
@Override
public Object generateId(Object forPojo) {
try {
return _property.get(forPojo);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new IllegalStateException("Problem accessing property '"
+_property.getName()+"': "+e.getMessage(), e);
}
}
@Override
public ObjectIdGenerator<Object> forScope(Class<?> scope) {
return (scope == _scope) ? this : new PropertyBasedObjectIdGenerator(scope, _property);
}
@Override
public ObjectIdGenerator<Object> newForSerialization(Object context) {
// No state
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, can return this
return this;
}
@Override
public com.fasterxml.jackson.annotation.ObjectIdGenerator.IdKey key(Object key) {
if (key == null) {
return null;
}
// should we use general type for all; or type of property itself?
return new IdKey(getClass(), _scope, key);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonArrayFormatVisitor;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatTypes;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.ser.std.ArraySerializerBase;
import com.fasterxml.jackson.databind.type.TypeFactory;
/**
* Standard serializer used for <code>String[]</code> values.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class StringArraySerializer
extends ArraySerializerBase<String[]>
implements ContextualSerializer
{
/* Note: not clean in general, but we are betting against
* anyone re-defining properties of String.class here...
*/
private final static JavaType VALUE_TYPE = TypeFactory.defaultInstance().uncheckedSimpleType(String.class);
public final static StringArraySerializer instance = new StringArraySerializer();
/**
* Value serializer to use, if it's not the standard one
* (if it is we can optimize serialization a lot)
*/
protected final JsonSerializer<Object> _elementSerializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
protected StringArraySerializer() {
super(String[].class, null);
_elementSerializer = null;
}
@SuppressWarnings("unchecked")
public StringArraySerializer(StringArraySerializer src,
BeanProperty prop, JsonSerializer<?> ser) {
super(src, prop);
_elementSerializer = (JsonSerializer<Object>) ser;
}
/**
* Strings never add type info; hence, even if
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> type serializer is suggested,
* we'll ignore it...
*/
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return this;
}
/*
/**********************************************************
/* Post-processing
/**********************************************************
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property)
throws JsonMappingException
{
/* 29-Sep-2012, tatu: Actually, we need to do much more contextual
* checking here since we finally know for sure the property,
* and it may have overrides
*/
JsonSerializer<?> ser = null;
// First: if we have a property, may have property-annotation overrides
if (property != null) {
AnnotatedMember m = property.getMember();
if (m != null) {
Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m);
if (serDef != null) {
ser = provider.serializerInstance(m, serDef);
}
}
}
if (ser == null) {
ser = _elementSerializer;
}
// #124: May have a content converter
ser = findConvertingContentSerializer(provider, property, ser);
if (ser == null) {
ser = provider.findValueSerializer(String.class, property);
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
// Optimization: default serializer just writes String, so we can avoid a call:
if (isDefaultSerializer(ser)) {
ser = null;
}
// note: will never have TypeSerializer, because Strings are "natural" type
if (ser == _elementSerializer) {
return this;
}
return new StringArraySerializer(this, property, ser);
}
/*
/**********************************************************
/* Simple accessors
/**********************************************************
*/
@Override
public JavaType getContentType() {
return VALUE_TYPE;
}
@Override
public JsonSerializer<?> getContentSerializer() {
return _elementSerializer;
}
@Override
public boolean isEmpty(SerializerProvider prov, String[] value) {
return (value == null) || (value.length == 0);
}
@Override
public boolean hasSingleElement(String[] value) {
return (value.length
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>y recursive generic
* type, to allow for sub-classing of build methods with property type
* co-variance.
*<p>
* Note on <code>JsonAutoDetect</code> annotation: it is used to
* access default minimum visibility access definitions.
*/
@JsonAutoDetect(
getterVisibility = Visibility.PUBLIC_ONLY,
isGetterVisibility = Visibility.PUBLIC_ONLY,
setterVisibility = Visibility.ANY,
/**
* By default, all matching single-arg constructed are found,
* regardless of visibility. Does not apply to factory methods,
* they can not be auto-detected; ditto for multiple-argument
* constructors.
*/
creatorVisibility = Visibility.ANY,
fieldVisibility = Visibility.PUBLIC_ONLY
)
public static class Std
implements VisibilityChecker<Std>,
java.io.Serializable
{
private static final long serialVersionUID = 1;
/**
* This is the canonical base instance, configured with default
* visibility values
*/
protected final static Std DEFAULT = new Std(Std.class.getAnnotation(JsonAutoDetect.class));
protected final Visibility _getterMinLevel;
protected final Visibility _isGetterMinLevel;
protected final Visibility _setterMinLevel;
protected final Visibility _creatorMinLevel;
protected final Visibility _fieldMinLevel;
public static Std defaultInstance() { return DEFAULT; }
/**
* Constructor used for building instance that has minumum visibility
* levels as indicated by given annotation instance
*
* @param ann Annotations to use for determining minimum visibility levels
*/
public Std(JsonAutoDetect ann)
{
// let's combine checks for enabled/disabled, with minimimum level checks:
_getterMinLevel = ann.getterVisibility();
_isGetterMinLevel = ann.isGetterVisibility();
_setterMinLevel = ann.setterVisibility();
_creatorMinLevel = ann.creatorVisibility();
_fieldMinLevel = ann.fieldVisibility();
}
/**
* Constructor that allows directly specifying minimum visibility levels to use
*/
public Std(Visibility getter, Visibility isGetter, Visibility setter, Visibility creator, Visibility field)
{
_getterMinLevel = getter;
_isGetterMinLevel = isGetter;
_setterMinLevel = setter;
_creatorMinLevel = creator;
_fieldMinLevel = field;
}
/**
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> return true;
}
@Override
public void serializeAsField(Object bean, JsonGenerator jgen, SerializerProvider prov)
throws Exception
{
final Object value = get(bean);
if (value == null) {
// Hmmh. I assume we MUST pretty much suppress nulls, since we
// can't really unwrap them...
return;
}
JsonSerializer<Object> ser = _serializer;
if (ser == null) {
Class<?> cls = value.getClass();
PropertySerializerMap map = _dynamicSerializers;
ser = map.serializerFor(cls);
if (ser == null) {
ser = _findAndAddDynamic(map, cls, prov);
}
}
if (_suppressableValue != null) {
if (MARKER_FOR_EMPTY == _suppressableValue) {
if (ser.isEmpty(prov, value)) {
return;
}
} else if (_suppressableValue.equals(value)) {
return;
}
}
// For non-nulls, first: simple check for direct cycles
if (value == bean) {
if (_handleSelfReference(bean, jgen, prov, ser)) {
return;
}
}
// note: must verify we are using unwrapping serializer; if not, will write field name
if (!ser.isUnwrappingSerializer()) {
jgen.writeFieldName(_name);
}
if (_typeSerializer == null) {
ser.serialize(value, jgen, prov);
} else {
ser.serializeWithType(value, jgen, prov, _typeSerializer);
}
}
// need to override as we must get unwrapping instance...
@Override
public void assignSerializer(JsonSerializer<Object> ser)
{
super.assignSerializer(ser);
if (_serializer != null) {
NameTransformer t = _nameTransformer;
if (_serializer.isUnwrappingSerializer()) {
t = NameTransformer.chainedTransformer(t, ((UnwrappingBeanSerializer) _serializer)._nameTransformer);
}
_serializer = _serializer.unwrappingSerializer(t);
}
}
/*
/**********************************************************
/* Overrides: schema generation
/**********************************************************
*/
@Override
public void depositSchemaProperty(final JsonObjectFormatVisitor visitor)
throws JsonMappingException {
SerializerProvider provider = visitor.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> given type.
* Note: "natural types" (String, Boolean, Integer, Double) will never
* use typing; that is both due to them being concrete and final,
* and since actual serializers and deserializers will also ignore any
* attempts to enforce typing.
*/
public boolean useForType(JavaType t)
{
switch (_appliesFor) {
case NON_CONCRETE_AND_ARRAYS:
while (t.isArrayType()) {
t = t.getContentType();
}
// fall through
case OBJECT_AND_NON_CONCRETE:
return (t.getRawClass() == Object.class) || !t.isConcrete()
// [Issue#88] Should not apply to JSON tree models:
|| TreeNode.class.isAssignableFrom(t.getRawClass());
case NON_FINAL:
while (t.isArrayType()) {
t = t.getContentType();
}
// [Issue#88] Should not apply to JSON tree models:
return !t.isFinal() && !TreeNode.class.isAssignableFrom(t.getRawClass());
default:
//case JAVA_LANG_OBJECT:
return (t.getRawClass() == Object.class);
}
}
}
/*
/**********************************************************
/* Internal constants, singletons
/**********************************************************
*/
// Quick little shortcut, to avoid having to use global TypeFactory instance...
private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class);
// 16-May-2009, tatu: Ditto ^^^
protected final static AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR = new JacksonAnnotationIntrospector();
protected final static VisibilityChecker<?> STD_VISIBILITY_CHECKER = VisibilityChecker.Std.defaultInstance();
protected final static PrettyPrinter _defaultPrettyPrinter = new DefaultPrettyPrinter();
/**
* Base settings contain defaults used for all {@link ObjectMapper}
* instances.
*/
protected final static BaseSettings DEFAULT_BASE = new BaseSettings(
null, // can not share global ClassIntrospector any more (2.5+)
DEFAULT_ANNOTATION_INTROSPECTOR,
STD_VISIBILITY_CHECKER, null, TypeFactory.defaultInstance(),
null, StdDateFormat.instance, null,
Locale.getDefault
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> Overridable helper method used to construct default {@link ClassIntrospector}
* to use.
*
* @since 2.5
*/
protected ClassIntrospector defaultClassIntrospector() {
return new BasicClassIntrospector();
}
/*
/**********************************************************
/* Methods sub-classes MUST override
/**********************************************************
*/
/**
* Method for creating a new {@link ObjectMapper} instance that
* has same initial configuration as this instance. Note that this
* also requires making a copy of the underlying {@link JsonFactory}
* instance.
*<p>
* Method is typically
* used when multiple, differently configured mappers are needed.
* Although configuration is shared, cached serializers and deserializers
* are NOT shared, which means that the new instance may be re-configured
* before use; meaning that it behaves the same way as if an instance
* was constructed from scratch.
*
* @since 2.1
*/
public ObjectMapper copy() {
_checkInvalidCopy(ObjectMapper.class);
return new ObjectMapper(this);
}
/**
* @since 2.1
*/
protected void _checkInvalidCopy(Class<?> exp)
{
if (getClass() != exp) {
throw new IllegalStateException("Failed copy(): "+getClass().getName()
+" (version: "+version()+") does not override copy(); it has to");
}
}
/*
/**********************************************************
/* Methods sub-classes MUST override if providing custom
/* ObjectReader/ObjectWriter implementations
/**********************************************************
*/
/**
* Factory method sub-classes must override, to produce {@link ObjectReader}
* instances of proper sub-type
*
* @since 2.5
*/
protected ObjectReader _newReader(DeserializationConfig config) {
return new ObjectReader(this, config);
}
/**
* Factory method sub-classes must override, to produce {@link ObjectReader}
* instances of proper sub-type
*
* @since 2.5
*/
protected ObjectReader _newReader(DeserializationConfig config,
JavaType valueType, Object valueToUpdate,
FormatSchema schema, InjectableValues injectableValues) {
return new ObjectReader(this, config, valueType, valueToUpdate, schema, injectableValues);
}
/**
* Factory method sub-classes must override
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, Class<?> mixinSource) {
mapper.addMixIn(target, mixinSource);
}
@Override
public void addDeserializationProblemHandler(DeserializationProblemHandler handler) {
mapper.addHandler(handler);
}
@Override
public void setNamingStrategy(PropertyNamingStrategy naming) {
mapper.setPropertyNamingStrategy(naming);
}
});
return this;
}
/**
* Convenience method for registering specified modules in order;
* functionally equivalent to:
*<pre>
* for (Module module : modules) {
* registerModule(module);
* }
*</pre>
*
* @since 2.2
*/
public ObjectMapper registerModules(Module... modules)
{
for (Module module : modules) {
registerModule(module);
}
return this;
}
/**
* Convenience method for registering specified modules in order;
* functionally equivalent to:
*<pre>
* for (Module module : modules) {
* registerModule(module);
* }
*</pre>
*
* @since 2.2
*/
public ObjectMapper registerModules(Iterable<Module> modules)
{
for (Module module : modules) {
registerModule(module);
}
return this;
}
/**
* Method for locating available methods, using JDK {@link ServiceLoader}
* facility, along with module-provided SPI.
*<p>
* Note that method does not do any caching, so calls should be considered
* potentially expensive.
*
* @since 2.2
*/
public static List<Module> findModules() {
return findModules(null);
}
/**
* Method for locating available methods, using JDK {@link ServiceLoader}
* facility, along with module-provided SPI.
*<p>
* Note that method does not do any caching, so calls should be considered
* potentially expensive.
*
* @since 2.2
*/
public static List<Module> findModules(ClassLoader classLoader)
{
ArrayList<Module> modules = new ArrayList<Module>();
ServiceLoader<Module> loader = (classLoader == null) ?
ServiceLoader.load(Module.class) : ServiceLoader.load(Module.class, classLoader);
for (Module module :
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> out of JSON tree
* representation.
*
* @param n Root node of the tree that resulting parser will read from
*/
@Override
public JsonParser treeAsTokens(TreeNode n) {
return new TreeTraversingParser((JsonNode) n, this);
}
/**
* Convenience conversion method that will bind data given JSON tree
* contains into specific value (usually bean) type.
*<p>
* Functionally equivalent to:
*<pre>
* objectMapper.convertValue(n, valueClass);
*</pre>
*/
@SuppressWarnings("unchecked")
@Override
public <T> T treeToValue(TreeNode n, Class<T> valueType)
throws JsonProcessingException
{
try {
// [Issue-11]: Simple cast when we just want to cast to, say, ObjectNode
// ... one caveat; while everything is Object.class, let's not take shortcut
if (valueType != Object.class && valueType.isAssignableFrom(n.getClass())) {
return (T) n;
}
return readValue(treeAsTokens(n), valueType);
} catch (JsonProcessingException e) {
throw e;
} catch (IOException e) { // should not occur, no real i/o...
throw new IllegalArgumentException(e.getMessage(), e);
}
}
/**
* Reverse of {@link #treeToValue}; given a value (usually bean), will
* construct equivalent JSON Tree representation. Functionally similar
* to serializing value into JSON and parsing JSON as tree, but
* more efficient.
*<p>
* NOTE: one known difference from actual serialization is that so-called
* "raw values" are not supported -- since they are opaque sequence of
* bytes to include (which may or may not be supported by the backend)
* they can not be converted using this method. It may be possible to
* support conversions using full serialization, if raw values must be
* preserved.
*
* @param <T> Actual node type; usually either basic {@link JsonNode} or
* {@link com.fasterxml.jackson.databind.node.ObjectNode}
* @param fromValue Bean value to convert
* @return Root node of the resulting JSON tree
*/
@SuppressWarnings({ "unchecked", "resource" })
public <T extends JsonNode
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>; instead give updateable object is used
* as root.
* Runtime type of value object is used for locating deserializer,
* unless overridden by other factory methods of {@link ObjectReader}
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T readerForUpdating(Object valueToUpdate) {
JavaType t = _typeFactory.constructType(valueToUpdate.getClass());
return (T) _newReader(getDeserializationConfig(), t, valueToUpdate,
null, _injectableValues);
}
/**
* Factory method for constructing {@link ObjectReader} that will
* read or update instances of specified type
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T reader(JavaType type) {
return (T) _newReader(getDeserializationConfig(), type, null,
null, _injectableValues);
}
/**
* Factory method for constructing {@link ObjectReader} that will
* read or update instances of specified type
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T reader(Class<?> type) {
return (T) _newReader(getDeserializationConfig(), _typeFactory.constructType(type), null,
null, _injectableValues);
}
/**
* Factory method for constructing {@link ObjectReader} that will
* read or update instances of specified type
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T reader(TypeReference<?> type) {
return (T)_newReader(getDeserializationConfig(), _typeFactory.constructType(type), null,
null, _injectableValues);
}
/**
* Factory method for constructing {@link ObjectReader} that will
* use specified {@link JsonNodeFactory} for constructing JSON trees.
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T reader(JsonNodeFactory f) {
return (T) _newReader(getDeserializationConfig()).with(f);
}
/**
* Factory method for constructing {@link ObjectReader} that will
* pass specific schema object to {@link JsonParser} used for
* reading content.
*
* @param schema Schema to pass to parser
*/
@SuppressWarnings("unchecked")
public <T extends ObjectReader> T reader(FormatSchema schema) {
_verifySchemaType(schema);
return (T)_newReader
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> convertValue(Object fromValue, Class<T> toValueType)
throws IllegalArgumentException
{
// sanity check for null first:
if (fromValue == null) return null;
return (T) _convert(fromValue, _typeFactory.constructType(toValueType));
}
@SuppressWarnings("unchecked")
public <T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef)
throws IllegalArgumentException
{
return (T) convertValue(fromValue, _typeFactory.constructType(toValueTypeRef));
}
@SuppressWarnings("unchecked")
public <T> T convertValue(Object fromValue, JavaType toValueType)
throws IllegalArgumentException
{
// sanity check for null first:
if (fromValue == null) return null;
return (T) _convert(fromValue, toValueType);
}
/**
* Actual conversion implementation: instead of using existing read
* and write methods, much of code is inlined. Reason for this is
* that we must avoid root value wrapping/unwrapping both for efficiency and
* for correctness. If root value wrapping/unwrapping is actually desired,
* caller must use explicit <code>writeValue</code> and
* <code>readValue</code> methods.
*/
@SuppressWarnings("resource")
protected Object _convert(Object fromValue, JavaType toValueType)
throws IllegalArgumentException
{
// also, as per [Issue-11], consider case for simple cast
/* But with caveats: one is that while everything is Object.class, we don't
* want to "optimize" that out; and the other is that we also do not want
* to lose conversions of generic types.
*/
Class<?> targetType = toValueType.getRawClass();
if (targetType != Object.class
&& !toValueType.hasGenericTypes()
&& targetType.isAssignableFrom(fromValue.getClass())) {
return fromValue;
}
/* Then use TokenBuffer, which is a JsonGenerator:
* (see [JACKSON-175])
*/
TokenBuffer buf = new TokenBuffer(this, false);
try {
// inlined 'writeValue' with minor changes:
// first: disable wrapping when writing
SerializationConfig config = getSerializationConfig().without(SerializationFeature.WRAP_ROOT_VALUE);
// no need to check for closing of TokenBuffer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>expName+"'), but "+p.getCurrentToken());
}
String actualName = p.getCurrentName();
if (!expName.equals(actualName)) {
throw JsonMappingException.from(p, "Root name '"+actualName+"' does not match expected ('"
+expName+"') for type "+rootType);
}
// ok, then move to value itself....
p.nextToken();
Object result = deser.deserialize(p, ctxt);
// and last, verify that we now get matching END_OBJECT
if (p.nextToken() != JsonToken.END_OBJECT) {
throw JsonMappingException.from(p, "Current token not END_OBJECT (to match wrapper object with root name '"
+expName+"'), but "+p.getCurrentToken());
}
return result;
}
/*
/**********************************************************
/* Internal methods, other
/**********************************************************
*/
/**
* Method called to locate deserializer for the passed root-level value.
*/
protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt,
JavaType valueType)
throws JsonMappingException
{
// First: have we already seen it?
JsonDeserializer<Object> deser = _rootDeserializers.get(valueType);
if (deser != null) {
return deser;
}
// Nope: need to ask provider to resolve it
deser = ctxt.findRootValueDeserializer(valueType);
if (deser == null) { // can this happen?
throw new JsonMappingException("Can not find a deserializer for type "+valueType);
}
_rootDeserializers.put(valueType, deser);
return deser;
}
/**
* @since 2.2
*/
protected void _verifySchemaType(FormatSchema schema)
{
if (schema != null) {
if (!_jsonFactory.canUseSchema(schema)) {
throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName()
+" for format "+_jsonFactory.getFormatName());
}
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect;
import java.lang.annotation.Annotation;
import java.util.*;
import com.fasterxml.jackson.annotation.*;
import com.fasterxml.jackson.core.Version;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.*;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import com.fasterxml.jackson.databind.cfg.MapperConfig;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeIdResolver;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.jsontype.impl.StdTypeResolverBuilder;
import com.fasterxml.jackson.databind.ser.BeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.VirtualBeanPropertyWriter;
import com.fasterxml.jackson.databind.ser.impl.AttributePropertyWriter;
import com.fasterxml.jackson.databind.ser.std.RawSerializer;
import com.fasterxml.jackson.databind.util.*;
/**
* {@link AnnotationIntrospector} implementation that handles standard
* Jackson annotations.
*/
public class JacksonAnnotationIntrospector
extends AnnotationIntrospector
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
public JacksonAnnotationIntrospector() { }
@Override
public Version version() {
return com.fasterxml.jackson.databind.cfg.PackageVersion.VERSION;
}
/*
/**********************************************************
/* General annotation properties
/**********************************************************
*/
/**
* Annotations with meta-annotation {@link JacksonAnnotationsInside}
* are considered bundles.
*/
@Override
public boolean isAnnotationBundle(Annotation ann) {
return ann.annotationType().getAnnotation(JacksonAnnotationsInside.class) != null;
}
/*
/**********************************************************
/* General annotations
/**********************************************************
*/
// default impl is fine:
//public String findEnumValue(Enum<?> value) { return value.name(); }
/*
/**********************************************************
/* General class annotations
/**********************************************************
*/
@Override
public PropertyName findRootName(AnnotatedClass ac)
{
JsonRootName
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> ann = _findAnnotation(ac, JsonRootName.class);
if (ann == null) {
return null;
}
String ns = ann.namespace();
if (ns != null && ns.length() == 0) {
ns = null;
}
return PropertyName.construct(ann.value(), ns);
}
@Override
public String[] findPropertiesToIgnore(Annotated ac) {
JsonIgnoreProperties ignore = _findAnnotation(ac, JsonIgnoreProperties.class);
return (ignore == null) ? null : ignore.value();
}
@Override
public Boolean findIgnoreUnknownProperties(AnnotatedClass ac) {
JsonIgnoreProperties ignore = _findAnnotation(ac, JsonIgnoreProperties.class);
return (ignore == null) ? null : ignore.ignoreUnknown();
}
@Override
public Boolean isIgnorableType(AnnotatedClass ac) {
JsonIgnoreType ignore = _findAnnotation(ac, JsonIgnoreType.class);
return (ignore == null) ? null : ignore.value();
}
/**
* @deprecated (since 2.3) Use {@link #findFilterId(Annotated)} instead
*/
@Deprecated
@Override
public Object findFilterId(AnnotatedClass ac) {
return _findFilterId(ac);
}
@Override
public Object findFilterId(Annotated a) {
return _findFilterId(a);
}
protected final Object _findFilterId(Annotated a)
{
JsonFilter ann = _findAnnotation(a, JsonFilter.class);
if (ann != null) {
String id = ann.value();
// Empty String is same as not having annotation, to allow overrides
if (id.length() > 0) {
return id;
}
}
return null;
}
@Override
public Object findNamingStrategy(AnnotatedClass ac)
{
JsonNaming ann = _findAnnotation(ac, JsonNaming.class);
return (ann == null) ? null : ann.value();
}
/*
/**********************************************************
/* Property auto-detection
/**********************************************************
*/
@Override
public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker)
{
JsonAutoDetect ann = _findAnnotation(ac, JsonAutoDetect.class);
return (ann == null) ? checker
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> : checker.with(ann);
}
/*
/**********************************************************
/* General member (field, method/constructor) annotations
/**********************************************************
*/
@Override
public ReferenceProperty findReferenceType(AnnotatedMember member)
{
JsonManagedReference ref1 = _findAnnotation(member, JsonManagedReference.class);
if (ref1 != null) {
return AnnotationIntrospector.ReferenceProperty.managed(ref1.value());
}
JsonBackReference ref2 = _findAnnotation(member, JsonBackReference.class);
if (ref2 != null) {
return AnnotationIntrospector.ReferenceProperty.back(ref2.value());
}
return null;
}
@Override
public NameTransformer findUnwrappingNameTransformer(AnnotatedMember member)
{
JsonUnwrapped ann = _findAnnotation(member, JsonUnwrapped.class);
// if not enabled, just means annotation is not enabled; not necessarily
// that unwrapping should not be done (relevant when using chained introspectors)
if (ann == null || !ann.enabled()) {
return null;
}
String prefix = ann.prefix();
String suffix = ann.suffix();
return NameTransformer.simpleTransformer(prefix, suffix);
}
@Override
public boolean hasIgnoreMarker(AnnotatedMember m) {
return _isIgnorable(m);
}
@Override
public Boolean hasRequiredMarker(AnnotatedMember m)
{
JsonProperty ann = _findAnnotation(m, JsonProperty.class);
if (ann != null) {
return ann.required();
}
return null;
}
@Override
public Object findInjectableValueId(AnnotatedMember m)
{
JacksonInject ann = _findAnnotation(m, JacksonInject.class);
if (ann == null) {
return null;
}
/* Empty String means that we should use name of declared
* value class.
*/
String id = ann.value();
if (id.length() == 0) {
// slight complication; for setters, type
if (!(m instanceof AnnotatedMethod)) {
return m.getRawType().getName();
}
AnnotatedMethod am = (AnnotatedMethod) m;
if (am.getParameterCount() == 0) {
return m.getRawType().getName();
}
return am.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>getRawParameterType(0).getName();
}
return id;
}
/*
/**********************************************************
/* Class annotations for PM type handling (1.5+)
/**********************************************************
*/
@Override
public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac, JavaType baseType)
{
return _findTypeResolver(config, ac, baseType);
}
@Override
public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am, JavaType baseType)
{
/* As per definition of @JsonTypeInfo, should only apply to contents of container
* (collection, map) types, not container types themselves:
*/
if (baseType.isContainerType()) return null;
// No per-member type overrides (yet)
return _findTypeResolver(config, am, baseType);
}
@Override
public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am, JavaType containerType)
{
/* First: let's ensure property is a container type: caller should have
* verified but just to be sure
*/
if (!containerType.isContainerType()) {
throw new IllegalArgumentException("Must call method with a container type (got "+containerType+")");
}
return _findTypeResolver(config, am, containerType);
}
@Override
public List<NamedType> findSubtypes(Annotated a)
{
JsonSubTypes t = _findAnnotation(a, JsonSubTypes.class);
if (t == null) return null;
JsonSubTypes.Type[] types = t.value();
ArrayList<NamedType> result = new ArrayList<NamedType>(types.length);
for (JsonSubTypes.Type type : types) {
result.add(new NamedType(type.value(), type.name()));
}
return result;
}
@Override
public String findTypeName(AnnotatedClass ac)
{
JsonTypeName tn = _findAnnotation(ac, JsonTypeName.class);
return (tn == null) ? null : tn.value();
}
/*
/**********************************************************
/* Serialization: general annotations
/**********************************************************
*/
@Override
public Object findSerializer(Annotated a)
{
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (ann != null) {
Class<? extends JsonSerializer<?>> serClass = ann.using();
if (serClass != JsonSerializer.None.class) {
return serClass;
}
}
/* 18-Oct-2010, tatu: [JACKSON-351] @JsonRawValue handled just here, for now;
* if we need to get raw indicator from other sources need to add
* separate accessor within {@link AnnotationIntrospector} interface.
*/
JsonRawValue annRaw = _findAnnotation(a, JsonRawValue.class);
if ((annRaw != null) && annRaw.value()) {
// let's construct instance with nominal type:
Class<?> cls = a.getRawType();
return new RawSerializer<Object>(cls);
}
return null;
}
@Override
public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a)
{
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
if (ann != null) {
Class<? extends JsonSerializer<?>> serClass = ann.keyUsing();
if (serClass != JsonSerializer.None.class) {
return serClass;
}
}
return null;
}
@Override
public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a)
{
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
if (ann != null) {
Class<? extends JsonSerializer<?>> serClass = ann.contentUsing();
if (serClass != JsonSerializer.None.class) {
return serClass;
}
}
return null;
}
@Override
public Object findNullSerializer(Annotated a)
{
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
if (ann != null) {
Class<? extends JsonSerializer<?>> serClass = ann.nullsUsing();
if (serClass != JsonSerializer.None.class) {
return serClass;
}
}
return null;
}
@Override
public JsonInclude.Include findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
{
JsonInclude inc = _findAnnotation(a, JsonInclude.class);
if (inc != null) {
return inc.value();
}
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>);
if (ann != null) {
@SuppressWarnings("deprecation")
JsonSerialize.Inclusion i2 = ann.include();
switch (i2) {
case ALWAYS:
return JsonInclude.Include.ALWAYS;
case NON_NULL:
return JsonInclude.Include.NON_NULL;
case NON_DEFAULT:
return JsonInclude.Include.NON_DEFAULT;
case NON_EMPTY:
return JsonInclude.Include.NON_EMPTY;
case DEFAULT_INCLUSION: // since 2.3 -- fall through, use default
break;
}
}
return defValue;
}
@Override
public JsonInclude.Include findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue)
{
JsonInclude inc = _findAnnotation(a, JsonInclude.class);
return (inc == null) ? defValue : inc.content();
}
@Override
public Class<?> findSerializationType(Annotated am)
{
JsonSerialize ann = _findAnnotation(am, JsonSerialize.class);
return (ann == null) ? null : _classIfExplicit(ann.as());
}
@Override
public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
{
JsonSerialize ann = _findAnnotation(am, JsonSerialize.class);
return (ann == null) ? null : _classIfExplicit(ann.keyAs());
}
@Override
public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
{
JsonSerialize ann = _findAnnotation(am, JsonSerialize.class);
return (ann == null) ? null : _classIfExplicit(ann.contentAs());
}
@Override
public JsonSerialize.Typing findSerializationTyping(Annotated a)
{
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
return (ann == null) ? null : ann.typing();
}
@Override
public Object findSerializationConverter(Annotated a) {
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
return (ann == null) ? null : _classIfExplicit(ann.converter(), Converter.None.class);
}
@Override
public Object findSerializationContentConverter(AnnotatedMember a) {
JsonSerialize ann = _findAnnotation(a, JsonSerialize.class);
return (ann
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> == null) ? null : _classIfExplicit(ann.contentConverter(), Converter.None.class);
}
@Override
public Class<?>[] findViews(Annotated a)
{
JsonView ann = _findAnnotation(a, JsonView.class);
return (ann == null) ? null : ann.value();
}
@Override
public Boolean isTypeId(AnnotatedMember member) {
return _hasAnnotation(member, JsonTypeId.class);
}
@Override
public ObjectIdInfo findObjectIdInfo(Annotated ann) {
JsonIdentityInfo info = _findAnnotation(ann, JsonIdentityInfo.class);
if (info == null || info.generator() == ObjectIdGenerators.None.class) {
return null;
}
// In future may need to allow passing namespace?
PropertyName name = new PropertyName(info.property());
return new ObjectIdInfo(name, info.scope(), info.generator(), info.resolver());
}
@Override
public ObjectIdInfo findObjectReferenceInfo(Annotated ann, ObjectIdInfo objectIdInfo) {
JsonIdentityReference ref = _findAnnotation(ann, JsonIdentityReference.class);
if (ref != null) {
objectIdInfo = objectIdInfo.withAlwaysAsId(ref.alwaysAsId());
}
return objectIdInfo;
}
@Override
public JsonFormat.Value findFormat(Annotated ann) {
JsonFormat f = _findAnnotation(ann, JsonFormat.class);
return (f == null) ? null : new JsonFormat.Value(f);
}
@Override
public String findPropertyDefaultValue(Annotated ann) {
JsonProperty prop = _findAnnotation(ann, JsonProperty.class);
if (prop == null) {
return null;
}
String str = prop.defaultValue();
// Since annotations do not allow nulls, need to assume empty means "none"
return str.isEmpty() ? null : str;
}
@Override
public String findPropertyDescription(Annotated ann) {
JsonPropertyDescription desc = _findAnnotation(ann, JsonPropertyDescription.class);
return (desc == null) ? null : desc.value();
}
@Override
public Integer findPropertyIndex(Annotated ann) {
JsonProperty prop = _findAnnotation(ann, JsonProperty.class);
if (prop != null) {
int
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> ix = prop.index();
if (ix != JsonProperty.INDEX_UNKNOWN) {
return Integer.valueOf(ix);
}
}
return null;
}
@Override
public String findImplicitPropertyName(AnnotatedMember param) {
// not known by default (until JDK8) for creators; default
//
return null;
}
/*
/**********************************************************
/* Serialization: class annotations
/**********************************************************
*/
@Override
public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
JsonPropertyOrder order = _findAnnotation(ac, JsonPropertyOrder.class);
return (order == null) ? null : order.value();
}
@Override
public Boolean findSerializationSortAlphabetically(Annotated ann) {
return _findSortAlpha(ann);
}
@Override
@Deprecated
public Boolean findSerializationSortAlphabetically(AnnotatedClass ac) {
return _findSortAlpha(ac);
}
private final Boolean _findSortAlpha(Annotated ann) {
JsonPropertyOrder order = _findAnnotation(ann, JsonPropertyOrder.class);
return (order == null) ? null : order.alphabetic();
}
@Override
public void findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac,
List<BeanPropertyWriter> properties) {
JsonAppend ann = _findAnnotation(ac, JsonAppend.class);
if (ann == null) {
return;
}
final boolean prepend = ann.prepend();
JavaType propType = null;
// First: any attribute-backed properties?
JsonAppend.Attr[] attrs = ann.attrs();
for (int i = 0, len = attrs.length; i < len; ++i) {
if (propType == null) {
propType = config.constructType(Object.class);
}
BeanPropertyWriter bpw = _constructVirtualProperty(attrs[i],
config, ac, propType);
if (prepend) {
properties.add(i, bpw);
} else {
properties.add(bpw);
}
}
// Then: general-purpose virtual properties?
JsonAppend.Prop[] props = ann.props();
for (int i = 0, len = props.length; i < len; ++i) {
BeanPropertyWriter bpw
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> hi.virtualPropertyWriterInstance(config, implClass);
if (bpw == null) {
bpw = (VirtualBeanPropertyWriter) ClassUtil.createInstance(implClass,
config.canOverrideAccessModifiers());
}
// one more thing: give it necessary contextual information
return bpw.withConfig(config, ac, propDef, type);
}
/*
/**********************************************************
/* Serialization: property annotations
/**********************************************************
*/
@Override
public PropertyName findNameForSerialization(Annotated a)
{
String name = null;
JsonGetter jg = _findAnnotation(a, JsonGetter.class);
if (jg != null) {
name = jg.value();
} else {
JsonProperty pann = _findAnnotation(a, JsonProperty.class);
if (pann != null) {
name = pann.value();
} else if (_hasAnnotation(a, JsonSerialize.class) || _hasAnnotation(a, JsonView.class)) {
name = "";
} else {
return null;
}
}
if (name.length() == 0) { // empty String means 'default'
return PropertyName.USE_DEFAULT;
}
return new PropertyName(name);
}
@Override
public boolean hasAsValueAnnotation(AnnotatedMethod am) {
JsonValue ann = _findAnnotation(am, JsonValue.class);
// value of 'false' means disabled...
return (ann != null && ann.value());
}
/*
/**********************************************************
/* Deserialization: general annotations
/**********************************************************
*/
@Override
public Class<? extends JsonDeserializer<?>> findDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
Class<? extends JsonDeserializer<?>> deserClass = ann.using();
if (deserClass != JsonDeserializer.None.class) {
return deserClass;
}
}
return null;
}
@Override
public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
Class<? extends KeyDeserializer> deserClass = ann.keyUsing();
if (deserClass != KeyDeserializer.None.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>class) {
return deserClass;
}
}
return null;
}
@Override
public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
if (ann != null) {
Class<? extends JsonDeserializer<?>> deserClass = ann.contentUsing();
if (deserClass != JsonDeserializer.None.class) {
return deserClass;
}
}
return null;
}
@Override
public Class<?> findDeserializationType(Annotated am, JavaType baseType) {
JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.as());
}
@Override
public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType) {
JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.keyAs());
}
@Override
public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType)
{
JsonDeserialize ann = _findAnnotation(am, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.contentAs());
}
@Override
public Object findDeserializationConverter(Annotated a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.converter(), Converter.None.class);
}
@Override
public Object findDeserializationContentConverter(AnnotatedMember a)
{
JsonDeserialize ann = _findAnnotation(a, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.contentConverter(), Converter.None.class);
}
/*
/**********************************************************
/* Deserialization: Class annotations
/**********************************************************
*/
@Override
public Object findValueInstantiator(AnnotatedClass ac)
{
JsonValueInstantiator ann = _findAnnotation(ac, JsonValueInstantiator.class);
// no 'null' marker yet, so:
return (ann == null) ? null : ann.value();
}
@Override
public Class<?> findPOJOBuilder(AnnotatedClass ac)
{
JsonDeserialize ann = _findAnnotation
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(ac, JsonDeserialize.class);
return (ann == null) ? null : _classIfExplicit(ann.builder());
}
@Override
public JsonPOJOBuilder.Value findPOJOBuilderConfig(AnnotatedClass ac)
{
JsonPOJOBuilder ann = _findAnnotation(ac, JsonPOJOBuilder.class);
return (ann == null) ? null : new JsonPOJOBuilder.Value(ann);
}
/*
/**********************************************************
/* Deserialization: property annotations
/**********************************************************
*/
@Override
public PropertyName findNameForDeserialization(Annotated a)
{
String name;
// @JsonSetter has precedence over @JsonProperty, being more specific
// @JsonDeserialize implies that there is a property, but no name
JsonSetter js = _findAnnotation(a, JsonSetter.class);
if (js != null) {
name = js.value();
} else {
JsonProperty pann = _findAnnotation(a, JsonProperty.class);
if (pann != null) {
name = pann.value();
/* 22-Apr-2014, tatu: Should figure out a better way to do this, but
* it's actually bit tricky to do it more efficiently (meta-annotations
* add more lookups; AnnotationMap costs etc)
*/
} else if (_hasAnnotation(a, JsonDeserialize.class)
|| _hasAnnotation(a, JsonView.class)
|| _hasAnnotation(a, JsonUnwrapped.class) // [#442]
|| _hasAnnotation(a, JsonBackReference.class)
|| _hasAnnotation(a, JsonManagedReference.class)) {
name = "";
} else {
return null;
}
}
if (name.length() == 0) { // empty String means 'default'
return PropertyName.USE_DEFAULT;
}
return new PropertyName(name);
}
@Override
public boolean hasAnySetterAnnotation(AnnotatedMethod am)
{
/* No dedicated disabling; regular @JsonIgnore used
* if needs to be ignored (and if so, is handled prior
* to this method getting called)
*/
return _hasAnnotation(am, JsonAnySetter.class);
}
@Override
public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
{
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
/* No dedicated disabling; regular @JsonIgnore used
* if needs to be ignored (handled separately
*/
return _hasAnnotation(am, JsonAnyGetter.class);
}
@Override
public boolean hasCreatorAnnotation(Annotated a)
{
/* No dedicated disabling; regular @JsonIgnore used
* if needs to be ignored (and if so, is handled prior
* to this method getting called)
*/
JsonCreator ann = _findAnnotation(a, JsonCreator.class);
return (ann != null && ann.mode() != JsonCreator.Mode.DISABLED);
}
@Override
public JsonCreator.Mode findCreatorBinding(Annotated a) {
JsonCreator ann = _findAnnotation(a, JsonCreator.class);
return (ann == null) ? null : ann.mode();
}
/*
/**********************************************************
/* Helper methods
/**********************************************************
*/
protected boolean _isIgnorable(Annotated a)
{
JsonIgnore ann = _findAnnotation(a, JsonIgnore.class);
return (ann != null && ann.value());
}
protected Class<?> _classIfExplicit(Class<?> cls) {
if (cls == null || ClassUtil.isBogusClass(cls)) {
return null;
}
return cls;
}
protected Class<?> _classIfExplicit(Class<?> cls, Class<?> implicit) {
cls = _classIfExplicit(cls);
return (cls == null || cls == implicit) ? null : cls;
}
protected PropertyName _propertyName(String localName, String namespace) {
if (localName.isEmpty()) {
return PropertyName.USE_DEFAULT;
}
if (namespace == null || namespace.isEmpty()) {
return new PropertyName(localName);
}
return new PropertyName(localName, namespace);
}
/**
* Helper method called to construct and initialize instance of {@link TypeResolverBuilder}
* if given annotated element indicates one is needed.
*/
@SuppressWarnings("deprecation")
protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> config,
Annotated ann, JavaType baseType)
{
// First: maybe we have explicit type resolver?
TypeResolverBuilder<?> b;
JsonTypeInfo info = _findAnnotation(ann, JsonTypeInfo.class);
JsonTypeResolver resAnn = _findAnnotation(ann, JsonType
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Resolver.class);
if (resAnn != null) {
if (info == null) {
return null;
}
/* let's not try to force access override (would need to pass
* settings through if we did, since that's not doable on some
* platforms)
*/
b = config.typeResolverBuilderInstance(ann, resAnn.value());
} else { // if not, use standard one, if indicated by annotations
if (info == null) {
return null;
}
// bit special; must return 'marker' to block use of default typing:
if (info.use() == JsonTypeInfo.Id.NONE) {
return _constructNoTypeResolverBuilder();
}
b = _constructStdTypeResolverBuilder();
}
// Does it define a custom type id resolver?
JsonTypeIdResolver idResInfo = _findAnnotation(ann, JsonTypeIdResolver.class);
TypeIdResolver idRes = (idResInfo == null) ? null
: config.typeIdResolverInstance(ann, idResInfo.value());
if (idRes != null) { // [JACKSON-359]
idRes.init(baseType);
}
b = b.init(info.use(), idRes);
/* 13-Aug-2011, tatu: One complication wrt [JACKSON-453]; external id
* only works for properties; so if declared for a Class, we will need
* to map it to "PROPERTY" instead of "EXTERNAL_PROPERTY"
*/
JsonTypeInfo.As inclusion = info.include();
if (inclusion == JsonTypeInfo.As.EXTERNAL_PROPERTY && (ann instanceof AnnotatedClass)) {
inclusion = JsonTypeInfo.As.PROPERTY;
}
b = b.inclusion(inclusion);
b = b.typeProperty(info.property());
Class<?> defaultImpl = info.defaultImpl();
// 08-Dec-2014, tatu: To deprecated `JsonTypeInfo.None` we need to use other placeholder(s);
// and since `java.util.Void` has other purpose (to indicate "deser as null"), we'll instead
// use `JsonTypeInfo.class` itself. But any annotation type will actually do, as they have no
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> // valid use (can not instantiate as default)
if (defaultImpl != JsonTypeInfo.None.class && !defaultImpl.isAnnotation()) {
b = b.defaultImpl(defaultImpl);
}
b = b.typeIdVisibility(info.visible());
return b;
}
/**
* Helper method for constructing standard {@link TypeResolverBuilder}
* implementation.
*/
protected StdTypeResolverBuilder _constructStdTypeResolverBuilder() {
return new StdTypeResolverBuilder();
}
/**
* Helper method for dealing with "no type info" marker; can't be null
* (as it'd be replaced by default typing)
*/
protected StdTypeResolverBuilder _constructNoTypeResolverBuilder() {
return StdTypeResolverBuilder.noTypeInfoBuilder();
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
/**
* Interface that can be implemented by objects that know how to
* serialize themselves to JSON, using {@link JsonGenerator}
* (and {@link SerializerProvider} if necessary).
*<p>
* Note that implementing this interface binds implementing object
* closely to Jackson API, and that it is often not necessary to do
* so -- if class is a bean, it can be serialized without
* implementing this interface.
*<p>
* NOTE: Jackson 2.0 added another method (from former "JsonSerializableWithType"),
* which is required for proper handling of case where additional type information
* is needed.
*/
public interface JsonSerializable
{
/**
* Serialization method called when no additional type information is
* to be included in serialization.
*/
public void serialize(JsonGenerator gen, SerializerProvider serializers) throws IOException;
/**
* Serialization method called when additional type information is
* expected to be included in serialization, for deserialization to use.
*<p>
* Usually implementation consists of a call to one of methods
* in {@link TypeSerializer} (such as {@link TypeSerializer#writeTypePrefixForObject(Object, JsonGenerator)})
* followed by serialization of contents,
* followed by another call to {@link TypeSerializer}
* (such as {@link TypeSerializer#writeTypeSuffixForObject(Object, JsonGenerator)}).
* Exact methods to call in {@link TypeSerializer} depend on shape of JSON Object used
* (Array, Object or scalar like String/Number/Boolean).
*<p>
* Note that some types (most notably, "natural" types: String, Integer,
* Double and Boolean) never include type information.
*/
public void serializeWithType(JsonGenerator gen, SerializerProvider serializers,
TypeSerializer typeSer) throws IOException;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> }
return;
}
// then find serializer to use
JsonSerializer<Object> ser = _serializer;
if (ser == null) {
Class<?> cls = value.getClass();
PropertySerializerMap m = _dynamicSerializers;
ser = m.serializerFor(cls);
if (ser == null) {
ser = _findAndAddDynamic(m, cls, prov);
}
}
// and then see if we must suppress certain values (default, empty)
if (_suppressableValue != null) {
if (MARKER_FOR_EMPTY == _suppressableValue) {
if (ser.isEmpty(prov, value)) {
return;
}
} else if (_suppressableValue.equals(value)) {
return;
}
}
// For non-nulls: simple check for direct cycles
if (value == bean) {
// three choices: exception; handled by call; or pass-through
if (_handleSelfReference(bean, gen, prov, ser)) {
return;
}
}
gen.writeFieldName(_name);
if (_typeSerializer == null) {
ser.serialize(value, gen, prov);
} else {
ser.serializeWithType(value, gen, prov, _typeSerializer);
}
}
/**
* Method called to indicate that serialization of a field was omitted
* due to filtering, in cases where backend data format does not allow
* basic omission.
*
* @since 2.3
*/
@Override
public void serializeAsOmittedField(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception
{
if (!gen.canOmitFields()) {
gen.writeOmittedField(_name.getValue());
}
}
/**
* Alternative to {@link #serializeAsField} that is used when a POJO
* is serialized as JSON Array; the difference is that no field names
* are written.
*
* @since 2.3
*/
@Override
public void serializeAsElement(Object bean, JsonGenerator gen, SerializerProvider prov)
throws Exception
{
// inlined 'get()'
final Object value = (_accessorMethod == null) ? _field.get(bean) : _accessorMethod.invoke(bean);
if (value == null) { // nulls need specialized handling
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (_nullSerializer != null) {
_nullSerializer.serialize(null, gen, prov);
} else { // can NOT suppress entries in tabular output
gen.writeNull();
}
return;
}
// otherwise find serializer to use
JsonSerializer<Object> ser = _serializer;
if (ser == null) {
Class<?> cls = value.getClass();
PropertySerializerMap map = _dynamicSerializers;
ser = map.serializerFor(cls);
if (ser == null) {
ser = _findAndAddDynamic(map, cls, prov);
}
}
// and then see if we must suppress certain values (default, empty)
if (_suppressableValue != null) {
if (MARKER_FOR_EMPTY == _suppressableValue) {
if (ser.isEmpty(prov, value)) { // can NOT suppress entries in tabular output
serializeAsPlaceholder(bean, gen, prov);
return;
}
} else if (_suppressableValue.equals(value)) { // can NOT suppress entries in tabular output
serializeAsPlaceholder(bean, gen, prov);
return;
}
}
// For non-nulls: simple check for direct cycles
if (value == bean) {
if (_handleSelfReference(bean, gen, prov, ser)) {
return;
}
}
if (_typeSerializer == null) {
ser.serialize(value, gen, prov);
} else {
ser.serializeWithType(value, gen, prov, _typeSerializer);
}
}
/**
* Method called to serialize a placeholder used in tabular output when
* real value is not to be included (is filtered out), but when we need
* an entry so that field indexes will not be off. Typically this should
* output null or empty String, depending on datatype.
*
* @since 2.1
*/
@Override
public void serializeAsPlaceholder(Object bean, JsonGenerator gen, SerializerProvider prov)
throws Exception
{
if (_nullSerializer != null) {
_nullSerializer.serialize(null, gen, prov);
} else {
gen.writeNull();
}
}
/*
/**********************************************************
/* PropertyWriter methods (schema generation)
/**********************************************************
*/
// Also part of BeanProperty implementation
@Override
public void depositSchema
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> '").append(getName()).append("' (");
if (_accessorMethod != null) {
sb.append("via method ").append(_accessorMethod.getDeclaringClass().getName()).append("#").append(_accessorMethod.getName());
} else if (_field != null) {
sb.append("field \"").append(_field.getDeclaringClass().getName()).append("#").append(_field.getName());
} else {
sb.append("virtual");
}
if (_serializer == null) {
sb.append(", no static serializer");
} else {
sb.append(", static serializer of type "+_serializer.getClass().getName());
}
sb.append(')');
return sb.toString();
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.util.UUID;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.TokenBuffer;
/**
* Specialized {@link JsonSerializer} to output {@link java.util.UUID}s.
* Beyond optimized access and writing of textual representation (which
* is the default handling in most cases), it will alternatively
* allow serialization using raw binary output (as 16-byte block)
* if underlying data format has efficient means to access that.
*/
@SuppressWarnings("serial")
public class UUIDSerializer
extends StdScalarSerializer<UUID>
{
final static char[] HEX_CHARS = "0123456789abcdef".toCharArray();
public UUIDSerializer() { super(UUID.class); }
@Override
@Deprecated // since 2.5
public boolean isEmpty(UUID value) {
return isEmpty(null, value);
}
@Override
public boolean isEmpty(SerializerProvider prov, UUID value)
{
if (value == null) {
return true;
}
// Null UUID is empty, so...
if (value.getLeastSignificantBits() == 0L
&& value.getMostSignificantBits() == 0L) {
return true;
}
return false;
}
@Override
public void serialize(UUID value, JsonGenerator gen, SerializerProvider provider)
throws IOException
{
// First: perhaps we could serialize it as raw binary data?
if (gen.canWriteBinaryNatively()) {
/* 07-Dec-2013, tatu: One nasty case; that of TokenBuffer. While it can
* technically retain binary data, we do not want to do use binary
* with it, as that results in UUIDs getting converted to Base64 for
* most conversions.
*/
if (!(gen instanceof TokenBuffer)) {
gen.writeBinary(_asBytes(value));
return;
}
}
// UUID.toString() works ok functionally, but we can make it go much faster
// (by 4x with micro-benchmark)
final char[] ch = new
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.cfg;
import java.text.DateFormat;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.core.Base64Variant;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.PropertyNamingStrategy;
import com.fasterxml.jackson.databind.introspect.ClassIntrospector;
import com.fasterxml.jackson.databind.introspect.VisibilityChecker;
import com.fasterxml.jackson.databind.jsontype.SubtypeResolver;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.type.ClassKey;
import com.fasterxml.jackson.databind.type.TypeFactory;
public abstract class MapperConfigBase<CFG extends ConfigFeature,
T extends MapperConfigBase<CFG,T>>
extends MapperConfig<T>
implements java.io.Serializable
{
private static final long serialVersionUID = 6062961959359172474L;
private final static int DEFAULT_MAPPER_FEATURES = collectFeatureDefaults(MapperFeature.class);
/*
/**********************************************************
/* Immutable config
/**********************************************************
*/
/**
* Mix-in annotation mappings to use, if any: immutable,
* can not be changed once defined.
*/
protected final Map<ClassKey,Class<?>> _mixInAnnotations;
/**
* Registered concrete subtypes that can be used instead of (or
* in addition to) ones declared using annotations.
*/
protected final SubtypeResolver _subtypeResolver;
/**
* Explicitly defined root name to use, if any; if empty
* String, will disable root-name wrapping; if null, will
* use defaults
*/
protected final String _rootName;
/**
* View to use for filtering out properties to serialize
* or deserialize.
* Null if none (will also be assigned null if <code>Object.class</code>
* is defined), meaning that all properties are
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.*;
import java.lang.reflect.Type;
import java.util.*;
import java.util.concurrent.atomic.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonIntegerFormatVisitor;
import com.fasterxml.jackson.databind.ser.BasicSerializerFactory;
/**
* Class that providers access to serializers user for non-structured JDK types that
* are serializer as scalars; some using basic {@link ToStringSerializer},
* others explicit serializers.
*/
@SuppressWarnings("serial")
public class StdJdkSerializers
{
/**
* Method called by {@link BasicSerializerFactory} to access
* all serializers this class provides.
*/
public static Collection<Map.Entry<Class<?>, Object>> all()
{
HashMap<Class<?>,Object> sers = new HashMap<Class<?>,Object>();
// First things that 'toString()' can handle
final ToStringSerializer sls = ToStringSerializer.instance;
sers.put(java.net.URL.class, sls);
sers.put(java.net.URI.class, sls);
sers.put(Currency.class, sls);
sers.put(UUID.class, new UUIDSerializer());
sers.put(java.util.regex.Pattern.class, sls);
sers.put(Locale.class, sls);
// starting with 1.7, use compact String for Locale
sers.put(Locale.class, sls);
// then atomic types
sers.put(AtomicReference.class, AtomicReferenceSerializer.class);
sers.put(AtomicBoolean.class, AtomicBooleanSerializer.class);
sers.put(AtomicInteger.class, AtomicIntegerSerializer.class);
sers.put(AtomicLong.class, AtomicLongSerializer.class);
// then other types that need specialized serializers
sers.put(File.class, FileSerializer.class);
sers.put(Class.class, ClassSerializer.class);
// And then some stranger types... not 100%
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> they are needed but:
sers.put(Void.class, NullSerializer.instance);
sers.put(Void.TYPE, NullSerializer.instance);
return sers.entrySet();
}
/*
/**********************************************************
/* Serializers for atomic types
/**********************************************************
*/
public static class AtomicBooleanSerializer
extends StdScalarSerializer<AtomicBoolean>
{
public AtomicBooleanSerializer() { super(AtomicBoolean.class, false); }
@Override
public void serialize(AtomicBoolean value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
jgen.writeBoolean(value.get());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("boolean", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException {
visitor.expectBooleanFormat(typeHint);
}
}
public static class AtomicIntegerSerializer
extends StdScalarSerializer<AtomicInteger>
{
public AtomicIntegerSerializer() { super(AtomicInteger.class, false); }
@Override
public void serialize(AtomicInteger value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
jgen.writeNumber(value.get());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("integer", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint);
if (v2 != null) {
v2.numberType(JsonParser.NumberType.INT);
}
}
}
public static class AtomicLongSerializer
extends StdScalarSerializer<AtomicLong>
{
public AtomicLongSerializer() { super(AtomicLong.class, false); }
@Override
public void serialize(AtomicLong value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
jgen.writeNumber(value.get());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("integer", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitor
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Wrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonIntegerFormatVisitor v2 = visitor.expectIntegerFormat(typeHint);
if (v2 != null) {
v2.numberType(JsonParser.NumberType.LONG);
}
}
}
public static class AtomicReferenceSerializer
extends StdSerializer<AtomicReference<?>>
{
public AtomicReferenceSerializer() { super(AtomicReference.class, false); }
@Override
public void serialize(AtomicReference<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonGenerationException {
provider.defaultSerializeValue(value.get(), jgen);
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("any", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
visitor.expectAnyFormat(typeHint);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.introspect;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.*;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.introspect.ClassIntrospector.MixInResolver;
import com.fasterxml.jackson.databind.util.Annotations;
import com.fasterxml.jackson.databind.util.ClassUtil;
public final class AnnotatedClass
extends Annotated
{
private final static AnnotationMap[] NO_ANNOTATION_MAPS = new AnnotationMap[0];
/*
/**********************************************************
/* Configuration
/**********************************************************
*/
/**
* Class for which annotations apply, and that owns other
* components (constructors, methods)
*/
final protected Class<?> _class;
/**
* Ordered set of super classes and interfaces of the
* class itself: included in order of precedence
*/
final protected List<Class<?>> _superTypes;
/**
* Filter used to determine which annotations to gather; used
* to optimize things so that unnecessary annotations are
* ignored.
*/
final protected AnnotationIntrospector _annotationIntrospector;
/**
* Object that knows mapping of mix-in classes (ones that contain
* annotations to add) with their target classes (ones that
* get these additional annotations "mixed in").
*/
final protected MixInResolver _mixInResolver;
/**
* Primary mix-in class; one to use for the annotated class
* itself. Can be null.
*/
final protected Class<?> _primaryMixIn;
/*
/**********************************************************
/* Gathered information
/**********************************************************
*/
/**
* Combined list of Jackson annotations that the class has,
* including inheritable ones from super classes and interfaces
*/
protected AnnotationMap _classAnnotations;
/**
* Flag to indicate whether creator information has been resolved
* or not.
*/
protected boolean _creatorsResolved = false;
/**
* Default constructor of the annotated class, if it has one.
*/
protected AnnotatedConstructor _defaultConstructor;
/**
* Single argument constructors the class has, if any.
*/
protected List<AnnotatedConstructor> _constructors;
/**
* Single argument static methods that might be usable
* as factory
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> methods
*/
protected List<AnnotatedMethod> _creatorMethods;
/**
* Member methods of interest; for now ones with 0 or 1 arguments
* (just optimization, since others won't be used now)
*/
protected AnnotatedMethodMap _memberMethods;
/**
* Member fields of interest: ones that are either public,
* or have at least one annotation.
*/
protected List<AnnotatedField> _fields;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
/**
* Constructor will not do any initializations, to allow for
* configuring instances differently depending on use cases
*/
private AnnotatedClass(Class<?> cls, List<Class<?>> superTypes,
AnnotationIntrospector aintr, MixInResolver mir,
AnnotationMap classAnnotations)
{
_class = cls;
_superTypes = superTypes;
_annotationIntrospector = aintr;
_mixInResolver = mir;
_primaryMixIn = (_mixInResolver == null) ? null
: _mixInResolver.findMixInClassFor(_class);
_classAnnotations = classAnnotations;
}
@Override
public AnnotatedClass withAnnotations(AnnotationMap ann) {
return new AnnotatedClass(_class, _superTypes,
_annotationIntrospector, _mixInResolver, ann);
}
/**
* Factory method that instantiates an instance. Returned instance
* will only be initialized with class annotations, but not with
* any method information.
*/
public static AnnotatedClass construct(Class<?> cls,
AnnotationIntrospector aintr, MixInResolver mir)
{
return new AnnotatedClass(cls,
ClassUtil.findSuperTypes(cls, null), aintr, mir, null);
}
/**
* Method similar to {@link #construct}, but that will NOT include
* information from supertypes; only class itself and any direct
* mix-ins it may have.
*/
public static AnnotatedClass constructWithoutSuperTypes(Class<?> cls,
AnnotationIntrospector aintr, MixInResolver mir)
{
return new AnnotatedClass(cls,
Collections.<Class<?>>emptyList(), aintr, mir, null);
}
/*
/**********************************************************
/* Annotated impl
/**********************************************************
*/
@Override
public Class<?> getAnnotated
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>() { return _class; }
@Override
public int getModifiers() { return _class.getModifiers(); }
@Override
public String getName() { return _class.getName(); }
@Override
public <A extends Annotation> A getAnnotation(Class<A> acls)
{
if (_classAnnotations == null) {
resolveClassAnnotations();
}
return _classAnnotations.get(acls);
}
@Override
public Type getGenericType() {
return _class;
}
@Override
public Class<?> getRawType() {
return _class;
}
@Override
public Iterable<Annotation> annotations() {
if (_classAnnotations == null) {
resolveClassAnnotations();
}
return _classAnnotations.annotations();
}
@Override
protected AnnotationMap getAllAnnotations() {
if (_classAnnotations == null) {
resolveClassAnnotations();
}
return _classAnnotations;
}
/*
/**********************************************************
/* Public API, generic accessors
/**********************************************************
*/
public Annotations getAnnotations() {
if (_classAnnotations == null) {
resolveClassAnnotations();
}
return _classAnnotations;
}
public boolean hasAnnotations() {
if (_classAnnotations == null) {
resolveClassAnnotations();
}
return _classAnnotations.size() > 0;
}
public AnnotatedConstructor getDefaultConstructor()
{
if (!_creatorsResolved) {
resolveCreators();
}
return _defaultConstructor;
}
public List<AnnotatedConstructor> getConstructors()
{
if (!_creatorsResolved) {
resolveCreators();
}
return _constructors;
}
public List<AnnotatedMethod> getStaticMethods()
{
if (!_creatorsResolved) {
resolveCreators();
}
return _creatorMethods;
}
public Iterable<AnnotatedMethod> memberMethods()
{
if (_memberMethods == null) {
resolveMemberMethods();
}
return _memberMethods;
}
public int getMemberMethodCount()
{
if (_memberMethods == null) {
resolveMemberMethods();
}
return _memberMethods.size();
}
public AnnotatedMethod findMethod(String name, Class<?>[] paramTypes)
{
if (_memberMethods == null) {
resolveMemberMethods();
}
return _memberMethods.find(name, param
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Types);
}
public int getFieldCount() {
if (_fields == null) {
resolveFields();
}
return _fields.size();
}
public Iterable<AnnotatedField> fields()
{
if (_fields == null) {
resolveFields();
}
return _fields;
}
/*
/**********************************************************
/* Public API, main-level resolution methods
/**********************************************************
*/
/**
* Initialization method that will recursively collect Jackson
* annotations for this class and all super classes and
* interfaces.
*/
private void resolveClassAnnotations()
{
_classAnnotations = new AnnotationMap();
// [JACKSON-659] Should skip processing if annotation processing disabled
if (_annotationIntrospector != null) {
// add mix-in annotations first (overrides)
if (_primaryMixIn != null) {
_addClassMixIns(_classAnnotations, _class, _primaryMixIn);
}
// first, annotations from the class itself:
_addAnnotationsIfNotPresent(_classAnnotations, _class.getDeclaredAnnotations());
// and then from super types
for (Class<?> cls : _superTypes) {
// and mix mix-in annotations in-between
_addClassMixIns(_classAnnotations, cls);
_addAnnotationsIfNotPresent(_classAnnotations, cls.getDeclaredAnnotations());
}
/* and finally... any annotations there might be for plain
* old Object.class: separate because for all other purposes
* it is just ignored (not included in super types)
*/
/* 12-Jul-2009, tatu: Should this be done for interfaces too?
* For now, yes, seems useful for some cases, and not harmful for any?
*/
_addClassMixIns(_classAnnotations, Object.class);
}
}
/**
* Initialization method that will find out all constructors
* and potential static factory methods the class has.
*/
private void resolveCreators()
{
// Then see which constructors we have
List<AnnotatedConstructor> constructors = null;
Constructor<?>[] declaredCtors = _class.getDeclaredConstructors();
for (Constructor<?> ctor : declaredCtors) {
if (ctor.getParameterTypes().length == 0) {
_defaultConstructor = _constructConstructor(ctor, true);
} else {
if (constructors == null
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>) {
constructors = new ArrayList<AnnotatedConstructor>(Math.max(10, declaredCtors.length));
}
constructors.add(_constructConstructor(ctor, false));
}
}
if (constructors == null) {
_constructors = Collections.emptyList();
} else {
_constructors = constructors;
}
// and if need be, augment with mix-ins
if (_primaryMixIn != null) {
if (_defaultConstructor != null || !_constructors.isEmpty()) {
_addConstructorMixIns(_primaryMixIn);
}
}
/* And then... let's remove all constructors that are deemed
* ignorable after all annotations have been properly collapsed.
*/
// 14-Feb-2011, tatu: AnnotationIntrospector is null if annotations not enabled; if so, can skip:
if (_annotationIntrospector != null) {
if (_defaultConstructor != null) {
if (_annotationIntrospector.hasIgnoreMarker(_defaultConstructor)) {
_defaultConstructor = null;
}
}
if (_constructors != null) {
// count down to allow safe removal
for (int i = _constructors.size(); --i >= 0; ) {
if (_annotationIntrospector.hasIgnoreMarker(_constructors.get(i))) {
_constructors.remove(i);
}
}
}
}
List<AnnotatedMethod> creatorMethods = null;
// Then static methods which are potential factory methods
for (Method m : _class.getDeclaredMethods()) {
if (!Modifier.isStatic(m.getModifiers())) {
continue;
}
// all factory methods are fine, as per [JACKSON-850]
//int argCount = m.getParameterTypes().length;
if (creatorMethods == null) {
creatorMethods = new ArrayList<AnnotatedMethod>(8);
}
creatorMethods.add(_constructCreatorMethod(m));
}
if (creatorMethods == null) {
_creatorMethods = Collections.emptyList();
} else {
_creatorMethods = creatorMethods;
// mix-ins to mix in?
if (_primaryMixIn != null) {
_addFactoryMixIns(_primaryMixIn);
}
// anything to ignore at this point?
if (_annotationIntrospector != null
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>) {
// count down to allow safe removal
for (int i = _creatorMethods.size(); --i >= 0; ) {
if (_annotationIntrospector.hasIgnoreMarker(_creatorMethods.get(i))) {
_creatorMethods.remove(i);
}
}
}
}
_creatorsResolved = true;
}
/**
* Method for resolving member method information: aggregating all non-static methods
* and combining annotations (to implement method-annotation inheritance)
*
* @param methodFilter Filter used to determine which methods to include
*/
private void resolveMemberMethods()
{
_memberMethods = new AnnotatedMethodMap();
AnnotatedMethodMap mixins = new AnnotatedMethodMap();
// first: methods from the class itself
_addMemberMethods(_class, _memberMethods, _primaryMixIn, mixins);
// and then augment these with annotations from super-types:
for (Class<?> cls : _superTypes) {
Class<?> mixin = (_mixInResolver == null) ? null : _mixInResolver.findMixInClassFor(cls);
_addMemberMethods(cls, _memberMethods, mixin, mixins);
}
// Special case: mix-ins for Object.class? (to apply to ALL classes)
if (_mixInResolver != null) {
Class<?> mixin = _mixInResolver.findMixInClassFor(Object.class);
if (mixin != null) {
_addMethodMixIns(_class, _memberMethods, mixin, mixins);
}
}
/* Any unmatched mix-ins? Most likely error cases (not matching
* any method); but there is one possible real use case:
* exposing Object#hashCode (alas, Object#getClass can NOT be
* exposed, see [JACKSON-140])
*/
// 14-Feb-2011, tatu: AnnotationIntrospector is null if annotations not enabled; if so, can skip:
if (_annotationIntrospector != null) {
if (!mixins.isEmpty()) {
Iterator<AnnotatedMethod> it = mixins.iterator();
while (it.hasNext()) {
AnnotatedMethod mixIn = it.next();
try {
Method m = Object.class.getDeclaredMethod(mixIn.getName(), mixIn.getRawParameterTypes());
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
if (m != null) {
AnnotatedMethod am = _constructMethod(m);
_addMixOvers(mixIn.getAnnotated(), am, false);
_memberMethods.add(am);
}
} catch (Exception e) { }
}
}
}
}
/**
* Method that will collect all member (non-static) fields
* that are either public, or have at least a single annotation
* associated with them.
*/
private void resolveFields()
{
Map<String,AnnotatedField> foundFields = _findFields(_class, null);
if (foundFields == null || foundFields.size() == 0) {
_fields = Collections.emptyList();
} else {
_fields = new ArrayList<AnnotatedField>(foundFields.size());
_fields.addAll(foundFields.values());
}
}
/*
/**********************************************************
/* Helper methods for resolving class annotations
/* (resolution consisting of inheritance, overrides,
/* and injection of mix-ins as necessary)
/**********************************************************
*/
/**
* Helper method for adding any mix-in annotations specified
* class might have.
*/
protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask)
{
if (_mixInResolver != null) {
_addClassMixIns(annotations, toMask, _mixInResolver.findMixInClassFor(toMask));
}
}
protected void _addClassMixIns(AnnotationMap annotations, Class<?> toMask,
Class<?> mixin)
{
if (mixin == null) {
return;
}
// Ok, first: annotations from mix-in class itself:
_addAnnotationsIfNotPresent(annotations, mixin.getDeclaredAnnotations());
/* And then from its supertypes, if any. But note that we will
* only consider super-types up until reaching the masked
* class (if found); this because often mix-in class
* is a sub-class (for convenience reasons). And if so, we
* absolutely must NOT include super types of masked class,
* as that would inverse precedence of annotations.
*/
for (Class<?> parent : ClassUtil.findSuperTypes(mixin, toMask)) {
_addAnnotationsIfNotPresent(annotations, parent.getDeclaredAnnotations());
}
}
/*
/**********************************************************
/* Helper
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> AnnotatedMethod target,
boolean addParamAnnotations)
{
_addOrOverrideAnnotations(target, mixin.getDeclaredAnnotations());
if (addParamAnnotations) {
Annotation[][] pa = mixin.getParameterAnnotations();
for (int i = 0, len = pa.length; i < len; ++i) {
for (Annotation a : pa[i]) {
target.addOrOverrideParam(i, a);
}
}
}
}
/**
* Method that will add annotations from specified source method to target method,
* but only if target does not yet have them.
*/
protected void _addMixUnders(Method src, AnnotatedMethod target) {
_addAnnotationsIfNotPresent(target, src.getDeclaredAnnotations());
}
private final boolean _isAnnotationBundle(Annotation ann) {
return (_annotationIntrospector != null) && _annotationIntrospector.isAnnotationBundle(ann);
}
/*
/**********************************************************
/* Other methods
/**********************************************************
*/
@Override
public String toString() {
return "[AnnotedClass "+_class.getName()+"]";
}
@Override
public int hashCode() {
return _class.getName().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
return ((AnnotatedClass) o)._class == _class;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import java.text.DateFormat;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
/**
* Compared to regular {@link java.util.Date} serialization, we do use String
* representation here. Why? Basically to truncate of time part, since
* that should not be used by plain SQL date.
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class SqlDateSerializer
extends DateTimeSerializerBase<java.sql.Date>
{
public SqlDateSerializer() {
/* 12-Apr-2014, tatu: for now, pass explicit 'false' to mean 'not using timestamp',
* for backwards compatibility; this differs from other Date/Calendar types.
*/
this(Boolean.FALSE);
}
protected SqlDateSerializer(Boolean useTimestamp) {
super(java.sql.Date.class, useTimestamp, null);
}
@Override
public SqlDateSerializer withFormat(Boolean timestamp, DateFormat customFormat) {
return new SqlDateSerializer(timestamp);
}
@Override
protected long _timestamp(java.sql.Date value) {
return (value == null) ? 0L : value.getTime();
}
@Override
public void serialize(java.sql.Date value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
if (_useTimestamp) {
jgen.writeNumber(_timestamp(value));
} else {
jgen.writeString(value.toString());
}
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
//todo: (ryan) add a format for the date in the schema?
return createSchemaNode("string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException
{
_acceptJson
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> PropertyWriter serialization method overrides
/**********************************************************
*/
@Override
public void serializeAsField(Object bean, JsonGenerator gen, SerializerProvider prov) throws Exception
{
// NOTE: mostly copied from base class, but off-lined get() access
final Object value = value(bean, gen, prov);
if (value == null) {
if (_nullSerializer != null) {
gen.writeFieldName(_name);
_nullSerializer.serialize(null, gen, prov);
}
return;
}
JsonSerializer<Object> ser = _serializer;
if (ser == null) {
Class<?> cls = value.getClass();
PropertySerializerMap m = _dynamicSerializers;
ser = m.serializerFor(cls);
if (ser == null) {
ser = _findAndAddDynamic(m, cls, prov);
}
}
if (_suppressableValue != null) {
if (MARKER_FOR_EMPTY == _suppressableValue) {
if (ser.isEmpty(prov, value)) {
return;
}
} else if (_suppressableValue.equals(value)) {
return;
}
}
if (value == bean) { // simple check for direct cycles
// three choices: exception; handled by call; or pass-through
if (_handleSelfReference(bean, gen, prov, ser)) {
return;
}
}
gen.writeFieldName(_name);
if (_typeSerializer == null) {
ser.serialize(value, gen, prov);
} else {
ser.serializeWithType(value, gen, prov, _typeSerializer);
}
}
// This one's fine as-is from base class
//public void serializeAsOmittedField(Object bean, JsonGenerator jgen, SerializerProvider prov) throws Exception
@Override
public void serializeAsElement(Object bean, JsonGenerator gen, SerializerProvider prov)
throws Exception
{
// NOTE: mostly copied from base class, but off-lined get() access
final Object value = value(bean, gen, prov);
if (value == null) {
if (_nullSerializer != null) {
_nullSerializer.serialize(null, gen, prov);
} else {
gen.writeNull();
}
return;
}
JsonSerializer<Object> ser = _serializer;
if (ser == null)
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> {
Class<?> cls = value.getClass();
PropertySerializerMap map = _dynamicSerializers;
ser = map.serializerFor(cls);
if (ser == null) {
ser = _findAndAddDynamic(map, cls, prov);
}
}
if (_suppressableValue != null) {
if (MARKER_FOR_EMPTY == _suppressableValue) {
if (ser.isEmpty(prov, value)) {
serializeAsPlaceholder(bean, gen, prov);
return;
}
} else if (_suppressableValue.equals(value)) {
serializeAsPlaceholder(bean, gen, prov);
return;
}
}
if (value == bean) {
if (_handleSelfReference(bean, gen, prov, ser)) {
return;
}
}
if (_typeSerializer == null) {
ser.serialize(value, gen, prov);
} else {
ser.serializeWithType(value, gen, prov, _typeSerializer);
}
}
// This one's fine as-is from base class
//public void serializeAsPlaceholder(Object bean, JsonGenerator jgen, SerializerProvider prov)
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
/**
* Also: default bean access will not do much good with Class.class. But
* we can just serialize the class name and that should be enough.
*/
@SuppressWarnings("serial")
public class ClassSerializer
extends StdScalarSerializer<Class<?>>
{
public ClassSerializer() { super(Class.class, false); }
@Override
public void serialize(Class<?> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeString(value.getName());
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
{
return createSchemaNode("string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
visitor.expectStringFormat(typeHint);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> public final static int TYPE_CURRENCY = 16;
final protected int _kind;
final protected Class<?> _keyClass;
/**
* Some types that are deserialized using a helper deserializer.
*/
protected final FromStringDeserializer<?> _deser;
protected StdKeyDeserializer(int kind, Class<?> cls) {
this(kind, cls, null);
}
protected StdKeyDeserializer(int kind, Class<?> cls, FromStringDeserializer<?> deser) {
_kind = kind;
_keyClass = cls;
_deser = deser;
}
public static StdKeyDeserializer forType(Class<?> raw)
{
int kind;
// first common types:
if (raw == String.class || raw == Object.class) {
return StringKD.forType(raw);
} else if (raw == UUID.class) {
kind = TYPE_UUID;
} else if (raw == Integer.class) {
kind = TYPE_INT;
} else if (raw == Long.class) {
kind = TYPE_LONG;
} else if (raw == Date.class) {
kind = TYPE_DATE;
} else if (raw == Calendar.class) {
kind = TYPE_CALENDAR;
// then less common ones...
} else if (raw == Boolean.class) {
kind = TYPE_BOOLEAN;
} else if (raw == Byte.class) {
kind = TYPE_BYTE;
} else if (raw == Character.class) {
kind = TYPE_CHAR;
} else if (raw == Short.class) {
kind = TYPE_SHORT;
} else if (raw == Float.class) {
kind = TYPE_FLOAT;
} else if (raw == Double.class) {
kind = TYPE_DOUBLE;
} else if (raw == URI.class) {
kind = TYPE_URI;
} else if (raw == URL.class) {
kind = TYPE_URL;
} else if (raw == Class.class) {
kind = TYPE_CLASS;
} else if (raw == Locale.class) {
FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Locale.class);
return new StdKeyDeserializer(TYPE_LOCALE, raw, deser);
} else if (raw == Currency.class) {
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
FromStringDeserializer<?> deser = FromStringDeserializer.findDeserializer(Currency.class);
return new StdKeyDeserializer(TYPE_CURRENCY, raw, deser);
} else {
return null;
}
return new StdKeyDeserializer(kind, raw);
}
@Override
public Object deserializeKey(String key, DeserializationContext ctxt)
throws IOException, JsonProcessingException
{
if (key == null) { // is this even legal call?
return null;
}
try {
Object result = _parse(key, ctxt);
if (result != null) {
return result;
}
} catch (Exception re) {
throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage());
}
if (_keyClass.isEnum() && ctxt.getConfig().isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) {
return null;
}
throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation");
}
public Class<?> getKeyClass() { return _keyClass; }
protected Object _parse(String key, DeserializationContext ctxt) throws Exception
{
switch (_kind) {
case TYPE_BOOLEAN:
if ("true".equals(key)) {
return Boolean.TRUE;
}
if ("false".equals(key)) {
return Boolean.FALSE;
}
throw ctxt.weirdKeyException(_keyClass, key, "value not 'true' or 'false'");
case TYPE_BYTE:
{
int value = _parseInt(key);
// as per [JACKSON-804], allow range up to 255, inclusive
if (value < Byte.MIN_VALUE || value > 255) {
throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 8-bit value");
}
return Byte.valueOf((byte) value);
}
case TYPE_SHORT:
{
int value = _parseInt(key);
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
throw ctxt.weirdKeyException(_keyClass, key, "overflow, value can not be represented as 16-bit value");
}
return Short.valueOf((
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>" deserializer
/**********************************************************
*/
@JacksonStdImpl
final static class StringKD extends StdKeyDeserializer
{
private static final long serialVersionUID = 1L;
private final static StringKD sString = new StringKD(String.class);
private final static StringKD sObject = new StringKD(Object.class);
private StringKD(Class<?> nominalType) { super(-1, nominalType); }
public static StringKD forType(Class<?> nominalType)
{
if (nominalType == String.class) {
return sString;
}
if (nominalType == Object.class) {
return sObject;
}
return new StringKD(nominalType);
}
@Override
public Object deserializeKey(String key, DeserializationContext ctxt) throws IOException, JsonProcessingException {
return key;
}
}
/*
/**********************************************************
/* Key deserializer implementations; other
/**********************************************************
*/
/**
* Key deserializer that wraps a "regular" deserializer (but one
* that must recognize FIELD_NAMEs as text!) to reuse existing
* handlers as key handlers.
*/
final static class DelegatingKD
extends KeyDeserializer // note: NOT the std one
implements java.io.Serializable
{
private static final long serialVersionUID = 1L;
final protected Class<?> _keyClass;
protected final JsonDeserializer<?> _delegate;
protected DelegatingKD(Class<?> cls, JsonDeserializer<?> deser) {
_keyClass = cls;
_delegate = deser;
}
@Override
public final Object deserializeKey(String key, DeserializationContext ctxt)
throws IOException, JsonProcessingException
{
if (key == null) { // is this even legal call?
return null;
}
try {
// Ugh... should not have to give parser which may or may not be correct one...
Object result = _delegate.deserialize(ctxt.getParser(), ctxt);
if (result != null) {
return result;
}
} catch (Exception re) {
throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation: "+re.getMessage());
}
throw ctxt.weirdKeyException(_keyClass, key, "not a valid representation");
}
public Class<?> getKeyClass() { return _keyClass; }
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
/**
* Intermediate base deserializer class that adds more shared accessor
* so that other classes can access information about contained (value)
* types
*/
@SuppressWarnings("serial")
public abstract class ContainerDeserializerBase<T>
extends StdDeserializer<T>
{
protected ContainerDeserializerBase(JavaType selfType) {
super(selfType);
}
/**
* @deprecated Since 2.3 use one that takes {@link JavaType}
*/
@Deprecated
protected ContainerDeserializerBase(Class<?> selfType) {
super(selfType);
}
/*
/**********************************************************
/* Overrides
/**********************************************************
*/
@Override
public SettableBeanProperty findBackReference(String refName) {
JsonDeserializer<Object> valueDeser = getContentDeserializer();
if (valueDeser == null) {
throw new IllegalArgumentException("Can not handle managed/back reference '"+refName
+"': type: container deserializer of type "+getClass().getName()+" returned null for 'getContentDeserializer()'");
}
return valueDeser.findBackReference(refName);
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Accessor for declared type of contained value elements; either exact
* type, or one of its supertypes.
*/
public abstract JavaType getContentType();
/**
* Accesor for deserializer use for deserializing content values.
*/
public abstract JsonDeserializer<Object> getContentDeserializer();
/*
/**********************************************************
/* Shared methods for sub-classes
/**********************************************************
*/
/**
* Helper method called by various Map(-like) deserializers.
*/
protected void wrapAndThrow(Throwable t, Object ref, String key) throws IOException
{
// to handle StackOverflow:
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors and "plain
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> public Reference(Object from, int index) {
_from = from;
_index = index;
}
public void setFrom(Object o) { _from = o; }
public void setFieldName(String n) { _fieldName = n; }
public void setIndex(int ix) { _index = ix; }
public Object getFrom() { return _from; }
public String getFieldName() { return _fieldName; }
public int getIndex() { return _index; }
@Override public String toString() {
StringBuilder sb = new StringBuilder();
Class<?> cls = (_from instanceof Class<?>) ?
((Class<?>)_from) : _from.getClass();
/* Hmmh. Although Class.getName() is mostly ok, it does look
* butt-ugly for arrays. So let's use getSimpleName() instead;
* but have to prepend package name too.
*/
Package pkg = cls.getPackage();
if (pkg != null) {
sb.append(pkg.getName());
sb.append('.');
}
sb.append(cls.getSimpleName());
sb.append('[');
if (_fieldName != null) {
sb.append('"');
sb.append(_fieldName);
sb.append('"');
} else if (_index >= 0) {
sb.append(_index);
} else {
sb.append('?');
}
sb.append(']');
return sb.toString();
}
}
/*
/**********************************************************
/* State/configuration
/**********************************************************
*/
/**
* Path through which problem that triggering throwing of
* this exception was reached.
*/
protected LinkedList<Reference> _path;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public JsonMappingException(String msg) { super(msg); }
public JsonMappingException(String msg, Throwable rootCause) { super(msg, rootCause); }
public JsonMappingException(String msg, JsonLocation loc) { super(msg, loc); }
public JsonMappingException(String msg, JsonLocation loc, Throwable rootCause) { super(msg, loc, rootCause); }
public static JsonMappingException from(JsonParser jp, String msg) {
return new JsonMappingException(msg, ((jp == null) ? null : jp.getTokenLocation()));
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
public static JsonMappingException from(JsonParser jp, String msg, Throwable problem) {
return new JsonMappingException(msg, ((jp == null) ? null : jp.getTokenLocation()), problem);
}
/**
* Factory method used when "upgrading" an {@link IOException} into
* {@link JsonMappingException}: usually only needed to comply with
* a signature.
*
* @since 2.1
*/
public static JsonMappingException fromUnexpectedIOE(IOException src) {
return new JsonMappingException("Unexpected IOException (of type "
+src.getClass().getName()+"): "+src.getMessage(), (JsonLocation)null, src);
}
/**
* Method that can be called to either create a new JsonMappingException
* (if underlying exception is not a JsonMappingException), or augment
* given exception with given path/reference information.
*
* This version of method is called when the reference is through a
* non-indexed object, such as a Map or POJO/bean.
*/
public static JsonMappingException wrapWithPath(Throwable src, Object refFrom,
String refFieldName) {
return wrapWithPath(src, new Reference(refFrom, refFieldName));
}
/**
* Method that can be called to either create a new JsonMappingException
* (if underlying exception is not a JsonMappingException), or augment
* given exception with given path/reference information.
*
* This version of method is called when the reference is through an
* index, which happens with arrays and Collections.
*/
public static JsonMappingException wrapWithPath(Throwable src, Object refFrom, int index) {
return wrapWithPath(src, new Reference(refFrom, index));
}
/**
* Method that can be called to either create a new JsonMappingException
* (if underlying exception is not a JsonMappingException), or augment
* given exception with given path/reference information.
*/
public static JsonMappingException wrapWithPath(Throwable src, Reference ref)
{
JsonMappingException jme;
if (src instanceof JsonMappingException) {
jme = (JsonMappingException) src;
} else {
String msg = src.getMessage();
/* Related to [JACKSON-62], let's use a more meaningful placeholder
* if all we have is
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> null
*/
if (msg == null || msg.length() == 0) {
msg = "(was "+src.getClass().getName()+")";
}
jme = new JsonMappingException(msg, null, src);
}
jme.prependPath(ref);
return jme;
}
/*
/**********************************************************
/* Accessors/mutators
/**********************************************************
*/
/**
* Method for accessing full structural path within type hierarchy
* down to problematic property.
*/
public List<Reference> getPath()
{
if (_path == null) {
return Collections.emptyList();
}
return Collections.unmodifiableList(_path);
}
/**
* Method for accesing description of path that lead to the
* problem that triggered this exception
*/
public String getPathReference()
{
return getPathReference(new StringBuilder()).toString();
}
public StringBuilder getPathReference(StringBuilder sb)
{
_appendPathDesc(sb);
return sb;
}
/**
* Method called to prepend a reference information in front of
* current path
*/
public void prependPath(Object referrer, String fieldName)
{
Reference ref = new Reference(referrer, fieldName);
prependPath(ref);
}
/**
* Method called to prepend a reference information in front of
* current path
*/
public void prependPath(Object referrer, int index)
{
Reference ref = new Reference(referrer, index);
prependPath(ref);
}
public void prependPath(Reference r)
{
if (_path == null) {
_path = new LinkedList<Reference>();
}
/* Also: let's not increase without bounds. Could choose either
* head or tail; tail is easier (no need to ever remove), as
* well as potentially more useful so let's use it:
*/
if (_path.size() < MAX_REFS_TO_LIST) {
_path.addFirst(r);
}
}
/*
/**********************************************************
/* Overridden methods
/**********************************************************
*/
@Override
public String getLocalizedMessage() {
return _buildMessage();
}
/**
* Method is overridden so that we can properly inject description
* of problem path, if such is defined.
*/
@Override
public String getMessage() {
return _buildMessage();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
protected String _buildMessage()
{
/* First: if we have no path info, let's just use parent's
* definition as is
*/
String msg = super.getMessage();
if (_path == null) {
return msg;
}
StringBuilder sb = (msg == null) ? new StringBuilder() : new StringBuilder(msg);
/* 18-Feb-2009, tatu: initially there was a linefeed between
* message and path reference; but unfortunately many systems
* (loggers, junit) seem to assume linefeeds are only added to
* separate stack trace.
*/
sb.append(" (through reference chain: ");
sb = getPathReference(sb);
sb.append(')');
return sb.toString();
}
@Override
public String toString()
{
return getClass().getName()+": "+getMessage();
}
/*
/**********************************************************
/* Internal methods
/**********************************************************
*/
protected void _appendPathDesc(StringBuilder sb)
{
if (_path == null) {
return;
}
Iterator<Reference> it = _path.iterator();
while (it.hasNext()) {
sb.append(it.next().toString());
if (it.hasNext()) {
sb.append("->");
}
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> = property;
_dynamicValueSerializers = PropertySerializerMap.emptyForProperties();
}
@SuppressWarnings("unchecked")
protected MapEntrySerializer(MapEntrySerializer src, BeanProperty property,
TypeSerializer vts,
JsonSerializer<?> keySer, JsonSerializer<?> valueSer)
{
super(Map.class, false);
_entryType = src._entryType;
_keyType = src._keyType;
_valueType = src._valueType;
_valueTypeIsStatic = src._valueTypeIsStatic;
_valueTypeSerializer = src._valueTypeSerializer;
_keySerializer = (JsonSerializer<Object>) keySer;
_valueSerializer = (JsonSerializer<Object>) valueSer;
_dynamicValueSerializers = src._dynamicValueSerializers;
_property = src._property;
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return new MapEntrySerializer(this, _property, vts, _keySerializer, _valueSerializer);
}
public MapEntrySerializer withResolved(BeanProperty property,
JsonSerializer<?> keySerializer, JsonSerializer<?> valueSerializer) {
return new MapEntrySerializer(this, property, _valueTypeSerializer, keySerializer, valueSerializer);
}
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property) throws JsonMappingException
{
JsonSerializer<?> ser = null;
JsonSerializer<?> keySer = null;
final AnnotationIntrospector intr = provider.getAnnotationIntrospector();
final AnnotatedMember propertyAcc = (property == null) ? null : property.getMember();
// First: if we have a property, may have property-annotation overrides
if (propertyAcc != null && intr != null) {
Object serDef = intr.findKeySerializer(propertyAcc);
if (serDef != null) {
keySer = provider.serializerInstance(propertyAcc, serDef);
}
serDef = intr.findContentSerializer(propertyAcc);
if (serDef != null) {
ser = provider.serializerInstance(propertyAcc, serDef);
}
}
if (ser == null) {
ser = _valueSerializer;
}
// [Issue#124]: May have a content converter
ser = findConvertingContentSerializer(provider, property, ser);
if (ser == null) {
// 30-Sep
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>-2012, tatu: One more thing -- if explicit content type is annotated,
// we can consider it a static case as well.
// 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho
if ((_valueTypeIsStatic && _valueType.getRawClass() != Object.class)
|| hasContentTypeAnnotation(provider, property)) {
ser = provider.findValueSerializer(_valueType, property);
}
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
if (keySer == null) {
keySer = _keySerializer;
}
if (keySer == null) {
keySer = provider.findKeySerializer(_keyType, property);
} else {
keySer = provider.handleSecondaryContextualization(keySer, property);
}
MapEntrySerializer mser = withResolved(property, keySer, ser);
// but note: no filtering, ignored entries or sorting (unlike Maps)
return mser;
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _valueType;
}
@Override
public JsonSerializer<?> getContentSerializer() {
return _valueSerializer;
}
@Override
public boolean hasSingleElement(Map.Entry<?,?> value) {
return true;
}
@Override
public boolean isEmpty(SerializerProvider prov, Entry<?, ?> value) {
return (value == null);
}
/*
/**********************************************************
/* Serialization methods
/**********************************************************
*/
@Override
public void serialize(Map.Entry<?, ?> value, JsonGenerator gen, SerializerProvider provider)
throws IOException
{
gen.writeStartObject();
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
if (_valueSerializer != null) {
serializeUsing(value, gen, provider, _valueSerializer);
} else {
serializeDynamic(value, gen, provider);
}
gen.writeEndObject();
}
@Override
public void serializeWithType(Map.Entry<?, ?> value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
typeSer.writeTypePrefixForObject
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(value, gen);
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
if (_valueSerializer != null) {
serializeUsing(value, gen, provider, _valueSerializer);
} else {
serializeDynamic(value, gen, provider);
}
typeSer.writeTypeSuffixForObject(value, gen);
}
protected void serializeDynamic(Map.Entry<?, ?> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException
{
final JsonSerializer<Object> keySerializer = _keySerializer;
final boolean skipNulls = !provider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES);
final TypeSerializer vts = _valueTypeSerializer;
PropertySerializerMap serializers = _dynamicValueSerializers;
Object valueElem = value.getValue();
Object keyElem = value.getKey();
if (keyElem == null) {
provider.findNullKeySerializer(_keyType, _property).serialize(null, jgen, provider);
} else {
// [JACKSON-314] skip entries with null values?
if (skipNulls && valueElem == null) return;
keySerializer.serialize(keyElem, jgen, provider);
}
// And then value
if (valueElem == null) {
provider.defaultSerializeNull(jgen);
} else {
Class<?> cc = valueElem.getClass();
JsonSerializer<Object> ser = serializers.serializerFor(cc);
if (ser == null) {
if (_valueType.hasGenericTypes()) {
ser = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_valueType, cc), provider);
} else {
ser = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicValueSerializers;
}
try {
if (vts == null) {
ser.serialize(valueElem, jgen, provider);
} else {
ser.serializeWithType(valueElem, jgen, provider, vts);
}
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
String keyDesc = ""+keyElem;
wrapAndThrow(provider, e, value, keyDesc);
}
}
}
/**
* Method called to
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> * {@link com.fasterxml.jackson.databind.ser.ResolvableSerializer} and
* {@link com.fasterxml.jackson.databind.ser.ContextualSerializer}
* are implemented, resolution of serializers occurs before
* contextualization.
*/
public abstract class JsonSerializer<T>
implements JsonFormatVisitable // since 2.1
{
/*
/**********************************************************
/* Fluent factory methods for constructing decorated versions
/**********************************************************
*/
/**
* Method that will return serializer instance that produces
* "unwrapped" serialization, if applicable for type being
* serialized (which is the case for some serializers
* that produce JSON Objects as output).
* If no unwrapped serializer can be constructed, will simply
* return serializer as-is.
*<p>
* Default implementation just returns serializer as-is,
* indicating that no unwrapped variant exists
*
* @param unwrapper Name transformation to use to convert between names
* of unwrapper properties
*/
public JsonSerializer<T> unwrappingSerializer(NameTransformer unwrapper) {
return this;
}
/**
* Method that can be called to try to replace serializer this serializer
* delegates calls to. If not supported (either this serializer does not
* delegate anything; or it does not want any changes), should either
* throw {@link UnsupportedOperationException} (if operation does not
* make sense or is not allowed); or return this serializer as is.
*
* @since 2.1
*/
public JsonSerializer<T> replaceDelegatee(JsonSerializer<?> delegatee) {
throw new UnsupportedOperationException();
}
/*
/**********************************************************
/* Serialization methods
/**********************************************************
*/
/**
* Method that can be called to ask implementation to serialize
* values of type this serializer handles.
*
* @param value Value to serialize; can <b>not</b> be null.
* @param gen Generator used to output resulting Json content
* @param serializers Provider that can be used to get serializers for
* serializing Objects value contains, if any.
*/
public abstract void serialize(T value, JsonGenerator gen, SerializerProvider serializers)
throws IOException, JsonProcessingException;
/**
* Method that can be called to ask implementation to serialize
* values of type this serializer handles, using specified type serializer
* for embedding necessary type information.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> *<p>
* Default implementation will throw {@link UnsupportedOperationException}
* to indicate that proper type handling needs to be implemented.
*<p>
* For simple datatypes written as a single scalar value (JSON String, Number, Boolean),
* implementation would look like:
*<pre>
* // note: method to call depends on whether this type is serialized as JSON scalar, object or Array!
* typeSer.writeTypePrefixForScalar(value, gen);
* serialize(value, gen, provider);
* typeSer.writeTypeSuffixForScalar(value, gen);
*</pre>
* and implementations for type serialized as JSON Arrays or Objects would differ slightly,
* as <code>START-ARRAY>/<code>END-ARRAY</code> and
* <code>START-OBJECT>/<code>END-OBJECT</code> pairs
* need to be properly handled with respect to serializing of contents.
*
* @param value Value to serialize; can <b>not</b> be null.
* @param gen Generator used to output resulting Json content
* @param serializers Provider that can be used to get serializers for
* serializing Objects value contains, if any.
* @param typeSer Type serializer to use for including type information
*/
public void serializeWithType(T value, JsonGenerator gen, SerializerProvider serializers,
TypeSerializer typeSer)
throws IOException
{
Class<?> clz = handledType();
if (clz == null) {
clz = value.getClass();
}
throw serializers.mappingException("Type id handling not implemented for type %s (by serializer of type %s)",
clz.getName(), getClass().getName());
}
/*
/**********************************************************
/* Other accessors
/**********************************************************
*/
/**
* Method for accessing type of Objects this serializer can handle.
* Note that this information is not guaranteed to be exact -- it
* may be a more generic (super-type) -- but it should not be
* incorrect (return a non-related type).
*<p>
* Default implementation will return null, which essentially means
* same as returning <code>Object.class</code> would; that is, that
* nothing is known about handled type.
*<p>
*/
public Class<T> handledType() { return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
import com.fasterxml.jackson.databind.ser.std.AsArraySerializerBase;
/**
* This is an optimized serializer for Lists that can be efficiently
* traversed by index (as opposed to others, such as {@link LinkedList}
* that can not}.
*/
@JacksonStdImpl
public final class IndexedListSerializer
extends AsArraySerializerBase<List<?>>
{
private static final long serialVersionUID = 1L;
public IndexedListSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts,
BeanProperty property, JsonSerializer<Object> valueSerializer)
{
super(List.class, elemType, staticTyping, vts, property, valueSerializer);
}
public IndexedListSerializer(IndexedListSerializer src,
BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer)
{
super(src, property, vts, valueSerializer);
}
@Override
public IndexedListSerializer withResolved(BeanProperty property,
TypeSerializer vts, JsonSerializer<?> elementSerializer) {
return new IndexedListSerializer(this, property, vts, elementSerializer);
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public boolean isEmpty(SerializerProvider prov, List<?> value) {
return (value == null) || value.isEmpty();
}
@Override
public boolean hasSingleElement(List<?> value) {
return (value.size() == 1);
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return new IndexedListSerializer(_elementType, _staticTyping, vts, _property, _elementSerializer);
}
@Override
public final void serialize(List<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.size();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) {
serializeContents(value, jgen, provider);
return;
}
jgen.writeStartArray(len);
serializeContents(value, jgen, provider);
jgen.writeEndArray();
}
@Override
public void serializeContents(List<?> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
if (_elementSerializer != null) {
serializeContentsUsing(value, jgen, provider, _elementSerializer);
return;
}
if (_valueTypeSerializer != null) {
serializeTypedContents(value, jgen, provider);
return;
}
final int len = value.size();
if (len == 0) {
return;
}
int i = 0;
try {
PropertySerializerMap serializers = _dynamicSerializers;
for (; i < len; ++i) {
Object elem = value.get(i);
if (elem == null) {
provider.defaultSerializeNull(jgen);
} else {
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
// To fix [JACKSON-508]
if (_elementType.hasGenericTypes()) {
serializer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_elementType, cc), provider);
} else {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicSerializers;
}
serializer.serialize(elem, jgen, provider);
}
}
} catch (Exception e) {
wrapAndThrow(provider, e, value, i);
}
}
public void serializeContentsUsing(List<?> value, JsonGenerator jgen, SerializerProvider provider,
JsonSerializer<Object> ser)
throws IOException
{
final int len = value.size();
if (len == 0) {
return;
}
final TypeSerializer typeSer = _valueTypeSerializer;
for (int i = 0; i < len; ++i) {
Object elem = value.get(i);
try {
if (elem == null) {
provider.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>defaultSerializeNull(jgen);
} else if (typeSer == null) {
ser.serialize(elem, jgen, provider);
} else {
ser.serializeWithType(elem, jgen, provider, typeSer);
}
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
wrapAndThrow(provider, e, value, i);
}
}
}
public void serializeTypedContents(List<?> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException
{
final int len = value.size();
if (len == 0) {
return;
}
int i = 0;
try {
final TypeSerializer typeSer = _valueTypeSerializer;
PropertySerializerMap serializers = _dynamicSerializers;
for (; i < len; ++i) {
Object elem = value.get(i);
if (elem == null) {
provider.defaultSerializeNull(jgen);
} else {
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
// To fix [JACKSON-508]
if (_elementType.hasGenericTypes()) {
serializer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_elementType, cc), provider);
} else {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicSerializers;
}
serializer.serializeWithType(elem, jgen, provider, typeSer);
}
}
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
wrapAndThrow(provider, e, value, i);
}
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> serialVersionUID = 1;
/**
* Set of {@link DeserializationFeature}s enabled.
*/
protected final int _deserFeatures;
/**
* Linked list that contains all registered problem handlers.
* Implementation as front-added linked list allows for sharing
* of the list (tail) without copying the list.
*/
protected final LinkedNode<DeserializationProblemHandler> _problemHandlers;
/**
* Factory used for constructing {@link com.fasterxml.jackson.databind.JsonNode} instances.
*/
protected final JsonNodeFactory _nodeFactory;
/**
* States of {@link com.fasterxml.jackson.core.JsonParser.Feature}s to enable/disable.
*/
protected final int _parserFeatures;
/**
* Bitflag of {@link com.fasterxml.jackson.core.JsonParser.Feature}s to enable/disable
*/
protected final int _parserFeaturesToChange;
/*
/**********************************************************
/* Life-cycle, constructors
/**********************************************************
*/
/**
* Constructor used by ObjectMapper to create default configuration object instance.
*/
public DeserializationConfig(BaseSettings base,
SubtypeResolver str, Map<ClassKey,Class<?>> mixins)
{
super(base, str, mixins);
_deserFeatures = collectFeatureDefaults(DeserializationFeature.class);
_nodeFactory = JsonNodeFactory.instance;
_problemHandlers = null;
_parserFeatures = 0;
_parserFeaturesToChange = 0;
}
private DeserializationConfig(DeserializationConfig src,
int mapperFeatures, int deserFeatures,
int parserFeatures, int parserFeatureMask)
{
super(src, mapperFeatures);
_deserFeatures = deserFeatures;
_nodeFactory = src._nodeFactory;
_problemHandlers = src._problemHandlers;
_parserFeatures = parserFeatures;
_parserFeaturesToChange = parserFeatureMask;
}
/**
* Copy constructor used to create a non-shared instance with given mix-in
* annotation definitions and subtype resolver.
*/
private DeserializationConfig(DeserializationConfig src, SubtypeResolver str)
{
super(src, str);
_deserFeatures = src._deserFeatures;
_nodeFactory = src._nodeFactory;
_problemHandlers = src._problemHandlers;
_parserFeatures = src._parserFeatures;
_parserFeaturesToChange =
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> + _index;
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
AnnotatedParameter other = (AnnotatedParameter) o;
return other._owner.equals(_owner) && (other._index == _index);
}
@Override
public String toString() {
return "[parameter #"+getIndex()+", annotations: "+_annotations+"]";
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>processing (ResolvableDeserializer)
/**********************************************************
*/
/**
* Method called to finalize setup of this deserializer,
* when it is known for which property deserializer is needed
* for.
*/
@Override
public CollectionDeserializer createContextual(DeserializationContext ctxt,
BeanProperty property) throws JsonMappingException
{
// May need to resolve types for delegate-based creators:
JsonDeserializer<Object> delegateDeser = null;
if ((_valueInstantiator != null) && _valueInstantiator.canCreateUsingDelegate()) {
JavaType delegateType = _valueInstantiator.getDelegateType(ctxt.getConfig());
if (delegateType == null) {
throw new IllegalArgumentException("Invalid delegate-creator definition for "+_collectionType
+": value instantiator ("+_valueInstantiator.getClass().getName()
+") returned true for 'canCreateUsingDelegate()', but null for 'getDelegateType()'");
}
delegateDeser = findDeserializer(ctxt, delegateType, property);
}
// also, often value deserializer is resolved here:
JsonDeserializer<?> valueDeser = _valueDeserializer;
// #125: May have a content converter
valueDeser = findConvertingContentDeserializer(ctxt, property, valueDeser);
final JavaType vt = _collectionType.getContentType();
if (valueDeser == null) {
valueDeser = ctxt.findContextualValueDeserializer(vt, property);
} else { // if directly assigned, probably not yet contextual, so:
valueDeser = ctxt.handleSecondaryContextualization(valueDeser, property, vt);
}
// and finally, type deserializer needs context as well
TypeDeserializer valueTypeDeser = _valueTypeDeserializer;
if (valueTypeDeser != null) {
valueTypeDeser = valueTypeDeser.forProperty(property);
}
return withResolved(delegateDeser, valueDeser, valueTypeDeser);
}
/*
/**********************************************************
/* ContainerDeserializerBase API
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _collectionType.getContentType();
}
@Override
public JsonDeserializer<Object> getContentDeserializer() {
return _valueDeserializer;
}
/*
/**********************************************************
/* JsonDeserializer API
/**********************************************************
*/
@SuppressWarnings("unchecked
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>resolvedForwardReference reference) {
if (referringAccumulator == null) {
throw JsonMappingException
.from(p, "Unresolved forward reference but no identity info", reference);
}
Referring ref = referringAccumulator.handleUnresolvedReference(reference);
reference.getRoid().appendReferring(ref);
} catch (Exception e) {
throw JsonMappingException.wrapWithPath(e, result, result.size());
}
}
return result;
}
@Override
public Object deserializeWithType(JsonParser jp, DeserializationContext ctxt,
TypeDeserializer typeDeserializer)
throws IOException
{
// In future could check current token... for now this should be enough:
return typeDeserializer.deserializeTypedFromArray(jp, ctxt);
}
/**
* Helper method called when current token is no START_ARRAY. Will either
* throw an exception, or try to handle value as if member of implicit
* array, depending on configuration.
*/
protected final Collection<Object> handleNonArray(JsonParser p, DeserializationContext ctxt,
Collection<Object> result)
throws IOException
{
// [JACKSON-526]: implicit arrays from single values?
if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
throw ctxt.mappingException(_collectionType.getRawClass());
}
JsonDeserializer<Object> valueDes = _valueDeserializer;
final TypeDeserializer typeDeser = _valueTypeDeserializer;
JsonToken t = p.getCurrentToken();
Object value;
try {
if (t == JsonToken.VALUE_NULL) {
value = valueDes.getNullValue();
} else if (typeDeser == null) {
value = valueDes.deserialize(p, ctxt);
} else {
value = valueDes.deserializeWithType(p, ctxt, typeDeser);
}
} catch (Exception e) {
// note: pass Object.class, not Object[].class, as we need element type for error info
throw JsonMappingException.wrapWithPath(e, Object.class, result.size());
}
result.add(value);
return result;
}
public final static class CollectionReferringAccumulator {
private final Class<?> _elementType;
private final Collection<Object> _result;
/**
* A list of {@link CollectionRef
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.util.TimeZone;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
@SuppressWarnings("serial")
public class TimeZoneSerializer extends StdScalarSerializer<TimeZone>
{
public TimeZoneSerializer() { super(TimeZone.class); }
@Override
public void serialize(TimeZone value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(value.getID());
}
@Override
public void serializeWithType(TimeZone value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer) throws IOException {
// Better ensure we don't use specific sub-classes:
typeSer.writeTypePrefixForScalar(value, jgen, TimeZone.class);
serialize(value, jgen, provider);
typeSer.writeTypeSuffixForScalar(value, jgen);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.*;
import java.nio.ByteBuffer;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.util.ByteBufferBackedInputStream;
@SuppressWarnings("serial")
public class ByteBufferSerializer extends StdScalarSerializer<ByteBuffer>
{
public ByteBufferSerializer() { super(ByteBuffer.class); }
@Override
public void serialize(ByteBuffer bbuf, JsonGenerator gen, SerializerProvider provider) throws IOException
{
// first, simple case when wrapping an array...
if (bbuf.hasArray()) {
gen.writeBinary(bbuf.array(), 0, bbuf.limit());
return;
}
// the other case is more complicated however. Best to handle with InputStream wrapper.
// But should we rewind it; and/or make a copy?
ByteBuffer copy = bbuf.asReadOnlyBuffer();
if (copy.position() > 0) {
copy.rewind();
}
InputStream in = new ByteBufferBackedInputStream(copy);
gen.writeBinary(in, copy.remaining());
in.close();
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser;
import java.lang.reflect.Method;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicReference;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.core.JsonLocation;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.cfg.DeserializerFactoryConfig;
import com.fasterxml.jackson.databind.cfg.HandlerInstantiator;
import com.fasterxml.jackson.databind.deser.impl.CreatorCollector;
import com.fasterxml.jackson.databind.deser.std.*;
import com.fasterxml.jackson.databind.ext.OptionalHandlerFactory;
import com.fasterxml.jackson.databind.introspect.*;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.type.*;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.EnumResolver;
import com.fasterxml.jackson.databind.util.NameTransformer;
import com.fasterxml.jackson.databind.util.TokenBuffer;
/**
* Abstract factory base class that can provide deserializers for standard
* JDK classes, including collection classes and simple heuristics for
* "upcasting" common collection interface types
* (such as {@link java.util.Collection}).
*<p>
* Since all simple deserializers are eagerly instantiated, and there is
* no additional introspection or customizability of these types,
* this factory is stateless.
*/
@SuppressWarnings("serial")
public abstract class BasicDeserializerFactory
extends DeserializerFactory
implements java.io.Serializable
{
private final static Class<?> CLASS_OBJECT = Object.class;
private final static Class<?> CLASS_STRING = String.class;
private final static Class<?> CLASS_CHAR_BUFFER = CharSequence.class;
private final static Class<?> CLASS_ITERABLE = Iterable.class;
private final static Class<?> CLASS_MAP_ENTRY = Map.Entry.class;
/**
* We
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> need a placeholder for creator properties that don't have name
* but are marked with `@JsonWrapped` annotation.
*/
protected final static PropertyName UNWRAPPED_CREATOR_PARAM_NAME = new PropertyName("@JsonUnwrapped");
/* We do some defaulting for abstract Map classes and
* interfaces, to avoid having to use exact types or annotations in
* cases where the most common concrete Maps will do.
*/
@SuppressWarnings("rawtypes")
final static HashMap<String, Class<? extends Map>> _mapFallbacks =
new HashMap<String, Class<? extends Map>>();
static {
_mapFallbacks.put(Map.class.getName(), LinkedHashMap.class);
_mapFallbacks.put(ConcurrentMap.class.getName(), ConcurrentHashMap.class);
_mapFallbacks.put(SortedMap.class.getName(), TreeMap.class);
_mapFallbacks.put(java.util.NavigableMap.class.getName(), TreeMap.class);
_mapFallbacks.put(java.util.concurrent.ConcurrentNavigableMap.class.getName(),
java.util.concurrent.ConcurrentSkipListMap.class);
}
/* We do some defaulting for abstract Collection classes and
* interfaces, to avoid having to use exact types or annotations in
* cases where the most common concrete Collection will do.
*/
@SuppressWarnings("rawtypes")
final static HashMap<String, Class<? extends Collection>> _collectionFallbacks =
new HashMap<String, Class<? extends Collection>>();
static {
_collectionFallbacks.put(Collection.class.getName(), ArrayList.class);
_collectionFallbacks.put(List.class.getName(), ArrayList.class);
_collectionFallbacks.put(Set.class.getName(), HashSet.class);
_collectionFallbacks.put(SortedSet.class.getName(), TreeSet.class);
_collectionFallbacks.put(Queue.class.getName(), LinkedList.class);
// then 1.6 types:
/* 17-May-2013, tatu: [Issue#216] Should be fine to use straight Class references EXCEPT
* that some godforsaken platforms (... looking at you, Android) do not
* include these. So, use "soft" references...
*/
_collectionFallbacks.put("java.util.Deque", LinkedList
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.class);
_collectionFallbacks.put("java.util.NavigableSet", TreeSet.class);
}
/*
/**********************************************************
/* Config
/**********************************************************
*/
/**
* Configuration settings for this factory; immutable instance (just like this
* factory), new version created via copy-constructor (fluent-style)
*/
protected final DeserializerFactoryConfig _factoryConfig;
/*
/**********************************************************
/* Life cycle
/**********************************************************
*/
protected BasicDeserializerFactory(DeserializerFactoryConfig config) {
_factoryConfig = config;
}
/**
* Method for getting current {@link DeserializerFactoryConfig}.
*<p>
* Note that since instances are immutable, you can NOT change settings
* by accessing an instance and calling methods: this will simply create
* new instance of config object.
*/
public DeserializerFactoryConfig getFactoryConfig() {
return _factoryConfig;
}
protected abstract DeserializerFactory withConfig(DeserializerFactoryConfig config);
/*
/********************************************************
/* Configuration handling: fluent factories
/********************************************************
*/
/**
* Convenience method for creating a new factory instance with additional deserializer
* provider.
*/
@Override
public final DeserializerFactory withAdditionalDeserializers(Deserializers additional) {
return withConfig(_factoryConfig.withAdditionalDeserializers(additional));
}
/**
* Convenience method for creating a new factory instance with additional
* {@link KeyDeserializers}.
*/
@Override
public final DeserializerFactory withAdditionalKeyDeserializers(KeyDeserializers additional) {
return withConfig(_factoryConfig.withAdditionalKeyDeserializers(additional));
}
/**
* Convenience method for creating a new factory instance with additional
* {@link BeanDeserializerModifier}.
*/
@Override
public final DeserializerFactory withDeserializerModifier(BeanDeserializerModifier modifier) {
return withConfig(_factoryConfig.withDeserializerModifier(modifier));
}
/**
* Convenience method for creating a new factory instance with additional
* {@link AbstractTypeResolver}.
*/
@Override
public final DeserializerFactory withAbstractTypeResolver(AbstractTypeResolver resolver) {
return withConfig(_factoryConfig.withAbstractTypeResolver(resolver));
}
/**
* Convenience method for creating a new factory instance with additional
* {@link ValueInstantiators}.
*/
@Override
public final DeserializerFactory withValueInstantiators
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> @JsonValueInstantiator before anything else
AnnotatedClass ac = beanDesc.getClassInfo();
Object instDef = ctxt.getAnnotationIntrospector().findValueInstantiator(ac);
if (instDef != null) {
instantiator = _valueInstantiatorInstance(config, ac, instDef);
}
if (instantiator == null) {
/* Second: see if some of standard Jackson/JDK types might provide value
* instantiators.
*/
instantiator = _findStdValueInstantiator(config, beanDesc);
if (instantiator == null) {
instantiator = _constructDefaultValueInstantiator(ctxt, beanDesc);
}
}
// finally: anyone want to modify ValueInstantiator?
if (_factoryConfig.hasValueInstantiators()) {
for (ValueInstantiators insts : _factoryConfig.valueInstantiators()) {
instantiator = insts.findValueInstantiator(config, beanDesc, instantiator);
// let's do sanity check; easier to spot buggy handlers
if (instantiator == null) {
throw new JsonMappingException("Broken registered ValueInstantiators (of type "
+insts.getClass().getName()+"): returned null ValueInstantiator");
}
}
}
// Sanity check: does the chosen instantatior have incomplete creators?
if (instantiator.getIncompleteParameter() != null) {
final AnnotatedParameter nonAnnotatedParam = instantiator.getIncompleteParameter();
final AnnotatedWithParams ctor = nonAnnotatedParam.getOwner();
throw new IllegalArgumentException("Argument #"+nonAnnotatedParam.getIndex()+" of constructor "+ctor+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator");
}
return instantiator;
}
private ValueInstantiator _findStdValueInstantiator(DeserializationConfig config,
BeanDescription beanDesc)
throws JsonMappingException
{
if (beanDesc.getBeanClass() == JsonLocation.class) {
return new JsonLocationInstantiator();
}
return null;
}
/**
* Method that will construct standard default {@link ValueInstantiator}
* using annotations (like @JsonCreator) and visibility rules
*/
protected ValueInstantiator _constructDefaultValueInstantiator(DeserializationContext ctxt,
BeanDescription beanDesc)
throws JsonMappingException
{
boolean fixAccess = ctxt.canOverrideAccessModifiers();
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> #"+index+" of "+owner
+" bound to more than one property; "+defs[index]+" vs "+propDef);
}
}
defs[index] = propDef;
}
}
return result;
}
public ValueInstantiator _valueInstantiatorInstance(DeserializationConfig config,
Annotated annotated, Object instDef)
throws JsonMappingException
{
if (instDef == null) {
return null;
}
ValueInstantiator inst;
if (instDef instanceof ValueInstantiator) {
return (ValueInstantiator) instDef;
}
if (!(instDef instanceof Class)) {
throw new IllegalStateException("AnnotationIntrospector returned key deserializer definition of type "
+instDef.getClass().getName()
+"; expected type KeyDeserializer or Class<KeyDeserializer> instead");
}
Class<?> instClass = (Class<?>)instDef;
if (ClassUtil.isBogusClass(instClass)) {
return null;
}
if (!ValueInstantiator.class.isAssignableFrom(instClass)) {
throw new IllegalStateException("AnnotationIntrospector returned Class "+instClass.getName()
+"; expected Class<ValueInstantiator>");
}
HandlerInstantiator hi = config.getHandlerInstantiator();
if (hi != null) {
inst = hi.valueInstantiatorInstance(config, annotated, instClass);
if (inst != null) {
return inst;
}
}
return (ValueInstantiator) ClassUtil.createInstance(instClass,
config.canOverrideAccessModifiers());
}
@Deprecated // since 2.5.0, removed from 2.6.0
protected void _addDeserializerConstructors(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators)
throws JsonMappingException
{
_addDeserializerConstructors(ctxt, beanDesc, vchecker, intr, creators,
Collections.<AnnotatedWithParams,BeanPropertyDefinition[]>emptyMap());
}
protected void _addDeserializerConstructors
(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators,
Map<AnnotatedWithParams,BeanPropertyDefinition[]> creatorParams)
throws JsonMappingException
{
// First things first: the "default constructor" (zero-arg
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>();
if ((ix == 0) && ClassUtil.isNonStaticInnerClass(ctor.getDeclaringClass())) {
throw new IllegalArgumentException("Non-static inner classes like "
+ctor.getDeclaringClass().getName()+" can not use @JsonCreator for constructors");
}
throw new IllegalArgumentException("Argument #"+ix
+" of constructor "+ctor+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator");
}
}
}
}
protected boolean _checkIfCreatorPropertyBased(AnnotationIntrospector intr,
AnnotatedWithParams creator, BeanPropertyDefinition propDef)
{
JsonCreator.Mode mode = intr.findCreatorBinding(creator);
if (mode == JsonCreator.Mode.PROPERTIES) {
return true;
}
if (mode == JsonCreator.Mode.DELEGATING) {
return false;
}
// If explicit name, or inject id, property-based
if (((propDef != null) && propDef.isExplicitlyNamed())
|| (intr.findInjectableValueId(creator.getParameter(0)) != null)) {
return true;
}
if (propDef != null) {
// One more thing: if implicit name matches property with a getter
// or field, we'll consider it property-based as well
String implName = propDef.getName();
if (implName != null && !implName.isEmpty()) {
if (propDef.couldSerialize()) {
return true;
}
}
}
// in absence of everything else, default to delegating
return false;
}
protected boolean _handleSingleArgumentConstructor(DeserializationContext ctxt,
BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators,
AnnotatedConstructor ctor, boolean isCreator, boolean isVisible)
throws JsonMappingException
{
// otherwise either 'simple' number, String, or general delegate:
Class<?> type = ctor.getRawParameterType(0);
if (type == String.class || type == CharSequence.class) {
if (isCreator || isVisible) {
creators.addStringCreator(ctor, isCreator);
}
return true;
}
if (type == int.class || type == Integer.class) {
if (isCreator || isVisible) {
creators.addInt
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Creator(ctor, isCreator);
}
return true;
}
if (type == long.class || type == Long.class) {
if (isCreator || isVisible) {
creators.addLongCreator(ctor, isCreator);
}
return true;
}
if (type == double.class || type == Double.class) {
if (isCreator || isVisible) {
creators.addDoubleCreator(ctor, isCreator);
}
return true;
}
if (type == boolean.class || type == Boolean.class) {
if (isCreator || isVisible) {
creators.addBooleanCreator(ctor, isCreator);
}
return true;
}
// Delegating Creator ok iff it has @JsonCreator (etc)
if (isCreator) {
creators.addDelegatingCreator(ctor, isCreator, null);
return true;
}
return false;
}
@Deprecated // since 2.5, remove from 2.6
protected void _addDeserializerFactoryMethods(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators)
throws JsonMappingException
{
_addDeserializerFactoryMethods(ctxt, beanDesc, vchecker, intr, creators,
Collections.<AnnotatedWithParams,BeanPropertyDefinition[]>emptyMap());
}
protected void _addDeserializerFactoryMethods
(DeserializationContext ctxt, BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators,
Map<AnnotatedWithParams,BeanPropertyDefinition[]> creatorParams)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
final boolean isCreator = intr.hasCreatorAnnotation(factory);
final int argCount = factory.getParameterCount();
// zero-arg methods must be annotated; if so, are "default creators" [JACKSON-850]
if (argCount == 0) {
if (isCreator) {
creators.setDefaultCreator(factory);
}
continue;
}
final BeanPropertyDefinition[] propDefs = creatorParams.get(factory);
// some single-arg factory methods (String, number) are auto-detected
if (argCount ==
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>, param, injectId);
continue;
}
}
/* 25-Sep-2014, tatu: Actually, we may end up "losing" naming due to higher-priority constructor
* (see TestCreators#testConstructorCreator() test). And just to avoid running into that problem,
* let's add one more work around
*/
/*
PropertyName name2 = _findExplicitParamName(param, intr);
if (name2 != null && !name2.isEmpty()) {
// Hmmh. Ok, fine. So what are we to do with it... ?
// For now... skip. May need to revisit this, should this become problematic
continue main_loop;
}
*/
if (nonAnnotatedParam == null) {
nonAnnotatedParam = param;
}
}
final int namedCount = explicitNameCount + implicitNameCount;
// Ok: if named or injectable, we have more work to do
if (isCreator || explicitNameCount > 0 || injectCount > 0) {
// simple case; everything covered:
if ((namedCount + injectCount) == argCount) {
creators.addPropertyCreator(factory, isCreator, properties);
} else if ((explicitNameCount == 0) && ((injectCount + 1) == argCount)) {
// [712] secondary: all but one injectable, one un-annotated (un-named)
creators.addDelegatingCreator(factory, isCreator, properties);
} else { // otherwise, epic fail
throw new IllegalArgumentException("Argument #"+nonAnnotatedParam.getIndex()
+" of factory method "+factory+" has no property name annotation; must have name when multiple-parameter constructor annotated as Creator");
}
}
}
}
protected boolean _handleSingleArgumentFactory(DeserializationConfig config,
BeanDescription beanDesc, VisibilityChecker<?> vchecker,
AnnotationIntrospector intr, CreatorCollector creators,
AnnotatedMethod factory, boolean isCreator)
throws JsonMappingException
{
Class<?> type = factory.getRawParameterType(0);
if (type == String.class || type == CharSequence.class) {
if (isCreator || vchecker.isCreatorVisible(factory)) {
creators.addStringCreator(factory, isCreator);
}
return true;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (type == int.class || type == Integer.class) {
if (isCreator || vchecker.isCreatorVisible(factory)) {
creators.addIntCreator(factory, isCreator);
}
return true;
}
if (type == long.class || type == Long.class) {
if (isCreator || vchecker.isCreatorVisible(factory)) {
creators.addLongCreator(factory, isCreator);
}
return true;
}
if (type == double.class || type == Double.class) {
if (isCreator || vchecker.isCreatorVisible(factory)) {
creators.addDoubleCreator(factory, isCreator);
}
return true;
}
if (type == boolean.class || type == Boolean.class) {
if (isCreator || vchecker.isCreatorVisible(factory)) {
creators.addBooleanCreator(factory, isCreator);
}
return true;
}
if (isCreator) {
creators.addDelegatingCreator(factory, isCreator, null);
return true;
}
return false;
}
/**
* Method that will construct a property object that represents
* a logical property passed via Creator (constructor or static
* factory method)
*/
protected CreatorProperty constructCreatorProperty(DeserializationContext ctxt,
BeanDescription beanDesc, PropertyName name, int index,
AnnotatedParameter param,
Object injectableValueId)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
final AnnotationIntrospector intr = ctxt.getAnnotationIntrospector();
PropertyMetadata metadata;
{
if (intr == null) {
metadata = PropertyMetadata.STD_REQUIRED_OR_OPTIONAL;
} else {
Boolean b = intr.hasRequiredMarker(param);
boolean req = (b != null && b.booleanValue());
String desc = intr.findPropertyDescription(param);
Integer idx = intr.findPropertyIndex(param);
String def = intr.findPropertyDefaultValue(param);
metadata = PropertyMetadata.construct(req, desc, idx, def);
}
}
JavaType t0 = config.getTypeFactory().constructType(param.getParameterType(), beanDesc.bindingsForBeanType());
BeanProperty.Std property = new BeanProperty.Std(name, t0,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> null;
}
protected PropertyName _findImplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
String str = intr.findImplicitPropertyName(param);
if (str != null && !str.isEmpty()) {
return new PropertyName(str);
}
return null;
}
protected boolean _hasExplicitParamName(AnnotatedParameter param, AnnotationIntrospector intr)
{
if (param != null && intr != null) {
PropertyName n = intr.findNameForDeserialization(param);
return (n != null) && n.hasSimpleName();
}
return false;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: array deserializers
/**********************************************************
*/
@Override
public JsonDeserializer<?> createArrayDeserializer(DeserializationContext ctxt,
ArrayType type, final BeanDescription beanDesc)
throws JsonMappingException
{
final DeserializationConfig config = ctxt.getConfig();
JavaType elemType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = elemType.getValueHandler();
// Then optional type info: if type has been resolved, we may already know type deserializer:
TypeDeserializer elemTypeDeser = elemType.getTypeHandler();
// but if not, may still be possible to find:
if (elemTypeDeser == null) {
elemTypeDeser = findTypeDeserializer(config, elemType);
}
// 23-Nov-2010, tatu: Custom array deserializer?
JsonDeserializer<?> deser = _findCustomArrayDeserializer(type,
config, beanDesc, elemTypeDeser, contentDeser);
if (deser == null) {
if (contentDeser == null) {
Class<?> raw = elemType.getRawClass();
if (elemType.isPrimitive()) {
return PrimitiveArrayDeserializers.forType(raw);
} else if (raw == String.class) {
return StringArrayDeserializer.instance;
}
}
deser = new ObjectArrayDeserializer(type, contentDeser, elemTypeDeser);
}
// and then new with 2.2: ability to post-process it too (Issue#120)
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyArrayDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
/*
/**********************************************************
/* JsonDeserializerFactory impl: Collection(-like) deserializers
/**********************************************************
*/
@Override
public JsonDeserializer<?> createCollectionDeserializer(DeserializationContext ctxt,
CollectionType type, BeanDescription beanDesc)
throws JsonMappingException
{
JavaType contentType = type.getContentType();
// Very first thing: is deserializer hard-coded for elements?
JsonDeserializer<Object> contentDeser = contentType.getValueHandler();
final DeserializationConfig config = ctxt.getConfig();
// Then optional type info (1.5): if type has been resolved, we may already know type deserializer:
TypeDeserializer contentTypeDeser = contentType.getTypeHandler();
// but if not, may still be possible to find:
if (contentTypeDeser == null) {
contentTypeDeser = findTypeDeserializer(config, contentType);
}
// 23-Nov-2010, tatu: Custom deserializer?
JsonDeserializer<?> deser = _findCustomCollectionDeserializer(type,
config, beanDesc, contentTypeDeser, contentDeser);
if (deser == null) {
Class<?> collectionClass = type.getRawClass();
if (contentDeser == null) { // not defined by annotation
// One special type: EnumSet:
if (EnumSet.class.isAssignableFrom(collectionClass)) {
deser = new EnumSetDeserializer(contentType, null);
}
}
}
/* One twist: if we are being asked to instantiate an interface or
* abstract Collection, we need to either find something that implements
* the thing, or give up.
*
* Note that we do NOT try to guess based on secondary interfaces
* here; that would probably not work correctly since casts would
* fail later on (as the primary type is not the interface we'd
* be implementing)
*/
if (deser == null) {
if (type.isInterface() || type.isAbstract()) {
CollectionType implType = _mapAbstractCollectionType(type, config);
if (implType == null) {
// [Issue#292]: Actually, may be fine, but only if polymorphich
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> deser enabled
if (type.getTypeHandler() == null) {
throw new IllegalArgumentException("Can not find a deserializer for non-concrete Collection type "+type);
}
deser = AbstractDeserializer.constructForNonPOJO(beanDesc);
} else {
type = implType;
// But if so, also need to re-check creators...
beanDesc = config.introspectForCreation(type);
}
}
if (deser == null) {
ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc);
if (!inst.canCreateUsingDefault()) {
// [Issue#161]: No default constructor for ArrayBlockingQueue...
if (type.getRawClass() == ArrayBlockingQueue.class) {
return new ArrayBlockingQueueDeserializer(type, contentDeser, contentTypeDeser, inst, null);
}
}
// 13-Dec-2010, tatu: Can use more optimal deserializer if content type is String, so:
if (contentType.getRawClass() == String.class) {
// no value type deserializer because Strings are one of natural/native types:
deser = new StringCollectionDeserializer(type, contentDeser, inst);
} else {
deser = new CollectionDeserializer(type, contentDeser, contentTypeDeser, inst);
}
}
}
// and then new with 2.2: ability to post-process it too (Issue#120)
if (_factoryConfig.hasDeserializerModifiers()) {
for (BeanDeserializerModifier mod : _factoryConfig.deserializerModifiers()) {
deser = mod.modifyCollectionDeserializer(config, type, beanDesc, deser);
}
}
return deser;
}
protected CollectionType _mapAbstractCollectionType(JavaType type, DeserializationConfig config)
{
Class<?> collectionClass = type.getRawClass();
collectionClass = _collectionFallbacks.get(collectionClass.getName());
if (collectionClass == null) {
return null;
}
return (CollectionType) config.constructSpecializedType(type, collectionClass);
}
// Copied almost verbatim from "createCollectionDeserializer" -- should try to share more code
@Override
public JsonDeserializer<?> createCollectionLikeDeserializer(DeserializationContext ctxt,
CollectionLikeType type, final BeanDescription beanDesc)
throws JsonMappingException
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> = _findCustomMapDeserializer(type, config, beanDesc,
keyDes, contentTypeDeser, contentDeser);
if (deser == null) {
// Value handling is identical for all, but EnumMap requires special handling for keys
Class<?> mapClass = type.getRawClass();
if (EnumMap.class.isAssignableFrom(mapClass)) {
Class<?> kt = keyType.getRawClass();
if (kt == null || !kt.isEnum()) {
throw new IllegalArgumentException("Can not construct EnumMap; generic (key) type not available");
}
deser = new EnumMapDeserializer(type, null, contentDeser, contentTypeDeser);
}
// Otherwise, generic handler works ok.
/* But there is one more twist: if we are being asked to instantiate
* an interface or abstract Map, we need to either find something
* that implements the thing, or give up.
*
* Note that we do NOT try to guess based on secondary interfaces
* here; that would probably not work correctly since casts would
* fail later on (as the primary type is not the interface we'd
* be implementing)
*/
if (deser == null) {
if (type.isInterface() || type.isAbstract()) {
@SuppressWarnings("rawtypes")
Class<? extends Map> fallback = _mapFallbacks.get(mapClass.getName());
if (fallback != null) {
mapClass = fallback;
type = (MapType) config.constructSpecializedType(type, mapClass);
// But if so, also need to re-check creators...
beanDesc = config.introspectForCreation(type);
} else {
// [Issue#292]: Actually, may be fine, but only if polymorphich deser enabled
if (type.getTypeHandler() == null) {
throw new IllegalArgumentException("Can not find a deserializer for non-concrete Map type "+type);
}
deser = AbstractDeserializer.constructForNonPOJO(beanDesc);
}
}
if (deser == null) {
ValueInstantiator inst = findValueInstantiator(ctxt, beanDesc);
MapDeserializer md = new MapDeserializer(type, inst, keyDes, contentDeser, contentTypeDeser);
md.setIgnorableProperties(config.getAnnotationIntrospector().findPropertiesTo
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>izers.constructDelegatingKeyDeserializer(config, type, custom);
}
EnumResolver<?> enumRes = constructEnumResolver(enumClass, config, beanDesc.findJsonValueMethod());
// [JACKSON-193] May have @JsonCreator for static factory method:
for (AnnotatedMethod factory : beanDesc.getFactoryMethods()) {
if (config.getAnnotationIntrospector().hasCreatorAnnotation(factory)) {
int argCount = factory.getParameterCount();
if (argCount == 1) {
Class<?> returnType = factory.getRawReturnType();
// usually should be class, but may be just plain Enum<?> (for Enum.valueOf()?)
if (returnType.isAssignableFrom(enumClass)) {
// note: mostly copied from 'EnumDeserializer.deserializerForCreator(...)'
if (factory.getGenericParameterType(0) != String.class) {
throw new IllegalArgumentException("Parameter #0 type for factory method ("+factory+") not suitable, must be java.lang.String");
}
if (config.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(factory.getMember());
}
return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes, factory);
}
}
throw new IllegalArgumentException("Unsuitable method ("+factory+") decorated with @JsonCreator (for Enum type "
+enumClass.getName()+")");
}
}
// [JACKSON-749] Also, need to consider @JsonValue, if one found
return StdKeyDeserializers.constructEnumKeyDeserializer(enumRes);
}
/*
/**********************************************************
/* Extended API
/**********************************************************
*/
/**
* Method called to create a type information deserializer for values of
* given non-container property, if one is needed.
* If not needed (no polymorphic handling configured for property), should return null.
*<p>
* Note that this method is only called for non-container bean properties,
* and not for values in container types or root values (or container properties)
*
* @param baseType Declared base type of the value to deserializer (actual
* deserializer type will be this type or its subtype)
*
* @return Type deserializer to use for given base type, if one is needed; null if not.
*/
public TypeDeserializer findPropertyTypeDeserializer
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Deserializer<?> findDefaultDeserializer(DeserializationContext ctxt,
JavaType type, BeanDescription beanDesc)
throws JsonMappingException
{
Class<?> rawType = type.getRawClass();
// Object ("untyped"), String equivalents:
if (rawType == CLASS_OBJECT) {
return new UntypedObjectDeserializer();
}
if (rawType == CLASS_STRING || rawType == CLASS_CHAR_BUFFER) {
return StringDeserializer.instance;
}
if (rawType == CLASS_ITERABLE) {
// [Issue#199]: Can and should 'upgrade' to a Collection type:
TypeFactory tf = ctxt.getTypeFactory();
JavaType[] tps = tf.findTypeParameters(type, CLASS_ITERABLE);
JavaType elemType = (tps == null || tps.length != 1) ? TypeFactory.unknownType() : tps[0];
CollectionType ct = tf.constructCollectionType(Collection.class, elemType);
// Should we re-introspect beanDesc? For now let's not...
return createCollectionDeserializer(ctxt, ct, beanDesc);
}
if (rawType == CLASS_MAP_ENTRY) {
final DeserializationConfig config = ctxt.getConfig();
TypeFactory tf = ctxt.getTypeFactory();
JavaType[] tps = tf.findTypeParameters(type, CLASS_MAP_ENTRY);
JavaType kt, vt;
if (tps == null || tps.length != 2) {
kt = vt = TypeFactory.unknownType();
} else {
kt = tps[0];
vt = tps[1];
}
TypeDeserializer vts = (TypeDeserializer) vt.getTypeHandler();
if (vts == null) {
vts = findTypeDeserializer(config, vt);
}
JsonDeserializer<Object> valueDeser = vt.getValueHandler();
KeyDeserializer keyDes = (KeyDeserializer) kt.getValueHandler();
return new MapEntryDeserializer(type, keyDes, valueDeser, vts);
}
String clsName = rawType.getName();
if (rawType.isPrimitive() || clsName.startsWith("java.")) {
// Primitives/wrappers, other Numbers:
JsonDeserializer<?> deser = NumberDeserializers.find(rawType, clsName);
if (deser == null) {
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> deser = DateDeserializers.find(rawType, clsName);
}
if (deser != null) {
return deser;
}
}
// and a few Jackson types as well:
if (rawType == TokenBuffer.class) {
return new TokenBufferDeserializer();
}
if (AtomicReference.class.isAssignableFrom(rawType)) {
// Must find parameterization
TypeFactory tf = ctxt.getTypeFactory();
JavaType[] params = tf.findTypeParameters(type, AtomicReference.class);
JavaType referencedType;
if (params == null || params.length < 1) { // untyped (raw)
referencedType = TypeFactory.unknownType();
} else {
referencedType = params[0];
}
TypeDeserializer vts = findTypeDeserializer(ctxt.getConfig(), referencedType);
BeanDescription refdDesc = ctxt.getConfig().introspectClassAnnotations(referencedType);
JsonDeserializer<?> deser = findDeserializerFromAnnotation(ctxt, refdDesc.getClassInfo());
return new AtomicReferenceDeserializer(referencedType, vts, deser);
}
JsonDeserializer<?> deser = findOptionalStdDeserializer(ctxt, type, beanDesc);
if (deser != null) {
return deser;
}
return JdkDeserializers.find(rawType, clsName);
}
/*
/**********************************************************
/* Helper methods, finding custom deserializers
/**********************************************************
*/
protected JsonDeserializer<?> _findCustomArrayDeserializer(ArrayType type,
DeserializationConfig config, BeanDescription beanDesc,
TypeDeserializer elementTypeDeserializer, JsonDeserializer<?> elementDeserializer)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findArrayDeserializer(type, config,
beanDesc, elementTypeDeserializer, elementDeserializer);
if (deser != null) {
return deser;
}
}
return null;
}
@SuppressWarnings("unchecked")
protected JsonDeserializer<Object> _findCustomBeanDeserializer(JavaType type,
DeserializationConfig config, BeanDescription beanDesc)
throws JsonMappingException
{
for (Deserializers d : _factoryConfig.deserializers()) {
JsonDeserializer<?> deser = d.findBeanDeserializer(type, config, beanDesc);
if (deser != null) {
return (Json
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
/**
* This is the special serializer for regular {@link java.lang.String}s.
*<p>
* Since this is one of "native" types, no type information is ever
* included on serialization (unlike for most scalar types as of 1.5)
*/
@JacksonStdImpl
public final class StringSerializer
extends NonTypedScalarSerializerBase<String>
{
private static final long serialVersionUID = 1L;
public StringSerializer() { super(String.class); }
/**
* For Strings, both null and Empty String qualify for emptiness.
*/
@Override
@Deprecated
public boolean isEmpty(String value) {
return (value == null) || (value.length() == 0);
}
@Override
public boolean isEmpty(SerializerProvider prov, String value) {
return (value == null) || (value.length() == 0);
}
@Override
public void serialize(String value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
jgen.writeString(value);
}
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint) {
return createSchemaNode("string", true);
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint) throws JsonMappingException {
if (visitor != null) visitor.expectStringFormat(typeHint);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import java.lang.reflect.Array;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.type.ArrayType;
import com.fasterxml.jackson.databind.util.ObjectBuffer;
/**
* Basic serializer that can serialize non-primitive arrays.
*/
@JacksonStdImpl
public class ObjectArrayDeserializer
extends ContainerDeserializerBase<Object[]>
implements ContextualDeserializer
{
private static final long serialVersionUID = 1L;
// // Configuration
/**
* Full generic type of the array being deserialized
*/
protected final ArrayType _arrayType;
/**
* Flag that indicates whether the component type is Object or not.
* Used for minor optimization when constructing result.
*/
protected final boolean _untyped;
/**
* Type of contained elements: needed for constructing actual
* result array
*/
protected final Class<?> _elementClass;
/**
* Element deserializer
*/
protected JsonDeserializer<Object> _elementDeserializer;
/**
* If element instances have polymorphic type information, this
* is the type deserializer that can handle it
*/
protected final TypeDeserializer _elementTypeDeserializer;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public ObjectArrayDeserializer(ArrayType arrayType,
JsonDeserializer<Object> elemDeser, TypeDeserializer elemTypeDeser)
{
super(arrayType);
_arrayType = arrayType;
_elementClass = arrayType.getContentType().getRawClass();
_untyped = (_elementClass == Object.class);
_elementDeserializer = elemDeser;
_elementTypeDeserializer = elemTypeDeser;
}
/**
* Overridable fluent-factory method used to create contextual instances
*/
@SuppressWarnings("unchecked")
public ObjectArrayDeserializer withDeserializer(TypeDeserializer elemTypeDeser,
JsonDeserializer<?> elemDeser)
{
if ((elemDeser == _elementDeserializer) && (elemTypeDeser ==
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>_STRING_AS_NULL_OBJECT)) {
String str = jp.getText();
if (str.length() == 0) {
return null;
}
}
// Can we do implicit coercion to a single-element array still?
if (!ctxt.isEnabled(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY)) {
/* 04-Oct-2009, tatu: One exception; byte arrays are generally
* serialized as base64, so that should be handled
*/
if (jp.getCurrentToken() == JsonToken.VALUE_STRING
&& _elementClass == Byte.class) {
return deserializeFromBase64(jp, ctxt);
}
throw ctxt.mappingException(_arrayType.getRawClass());
}
JsonToken t = jp.getCurrentToken();
Object value;
if (t == JsonToken.VALUE_NULL) {
value = _elementDeserializer.getNullValue();
} else if (_elementTypeDeserializer == null) {
value = _elementDeserializer.deserialize(jp, ctxt);
} else {
value = _elementDeserializer.deserializeWithType(jp, ctxt, _elementTypeDeserializer);
}
// Ok: bit tricky, since we may want T[], not just Object[]
Object[] result;
if (_untyped) {
result = new Object[1];
} else {
result = (Object[]) Array.newInstance(_elementClass, 1);
}
result[0] = value;
return result;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
import com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap;
/**
* Fallback serializer for cases where Collection is not known to be
* of type for which more specializer serializer exists (such as
* index-accessible List).
* If so, we will just construct an {@link java.util.Iterator}
* to iterate over elements.
*/
public class CollectionSerializer
extends AsArraySerializerBase<Collection<?>>
{
private static final long serialVersionUID = 1L;
/*
/**********************************************************
/* Life-cycle
/**********************************************************
*/
public CollectionSerializer(JavaType elemType, boolean staticTyping, TypeSerializer vts,
BeanProperty property, JsonSerializer<Object> valueSerializer)
{
super(Collection.class, elemType, staticTyping, vts, property, valueSerializer);
}
public CollectionSerializer(CollectionSerializer src,
BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer)
{
super(src, property, vts, valueSerializer);
}
@Override
public ContainerSerializer<?> _withValueTypeSerializer(TypeSerializer vts) {
return new CollectionSerializer(_elementType, _staticTyping, vts, _property, _elementSerializer);
}
@Override
public CollectionSerializer withResolved(BeanProperty property,
TypeSerializer vts, JsonSerializer<?> elementSerializer) {
return new CollectionSerializer(this, property, vts, elementSerializer);
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public boolean isEmpty(SerializerProvider prov, Collection<?> value) {
return (value == null) || value.isEmpty();
}
@Override
public boolean hasSingle
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Element(Collection<?> value) {
Iterator<?> it = value.iterator();
if (!it.hasNext()) {
return false;
}
it.next();
return !it.hasNext();
}
/*
/**********************************************************
/* Actual serialization
/**********************************************************
*/
@Override
public final void serialize(Collection<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.size();
if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) {
serializeContents(value, jgen, provider);
return;
}
jgen.writeStartArray(len);
serializeContents(value, jgen, provider);
jgen.writeEndArray();
}
@Override
public void serializeContents(Collection<?> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
if (_elementSerializer != null) {
serializeContentsUsing(value, jgen, provider, _elementSerializer);
return;
}
Iterator<?> it = value.iterator();
if (!it.hasNext()) {
return;
}
PropertySerializerMap serializers = _dynamicSerializers;
final TypeSerializer typeSer = _valueTypeSerializer;
int i = 0;
try {
do {
Object elem = it.next();
if (elem == null) {
provider.defaultSerializeNull(jgen);
} else {
Class<?> cc = elem.getClass();
JsonSerializer<Object> serializer = serializers.serializerFor(cc);
if (serializer == null) {
// To fix [JACKSON-508]
if (_elementType.hasGenericTypes()) {
serializer = _findAndAddDynamic(serializers,
provider.constructSpecializedType(_elementType, cc), provider);
} else {
serializer = _findAndAddDynamic(serializers, cc, provider);
}
serializers = _dynamicSerializers;
}
if (typeSer == null) {
serializer.serialize(elem, jgen, provider);
} else {
serializer.serializeWithType(elem, jgen, provider, typeSer);
}
}
++i;
} while (it.hasNext());
} catch (Exception e) {
// [JACKSON-55] Need to add reference information
wrapAnd
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.util.*;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
@SuppressWarnings("serial")
public class EnumSetSerializer
extends AsArraySerializerBase<EnumSet<? extends Enum<?>>>
{
public EnumSetSerializer(JavaType elemType, BeanProperty property)
{
super(EnumSet.class, elemType, true, null, property, null);
}
public EnumSetSerializer(EnumSetSerializer src,
BeanProperty property, TypeSerializer vts, JsonSerializer<?> valueSerializer)
{
super(src, property, vts, valueSerializer);
}
@Override
public EnumSetSerializer _withValueTypeSerializer(TypeSerializer vts) {
// no typing for enums (always "hard" type)
return this;
}
@Override
public EnumSetSerializer withResolved(BeanProperty property,
TypeSerializer vts, JsonSerializer<?> elementSerializer) {
return new EnumSetSerializer(this, property, vts, elementSerializer);
}
@Override
public boolean isEmpty(SerializerProvider prov, EnumSet<? extends Enum<?>> value) {
return (value == null) || value.isEmpty();
}
@Override
public boolean hasSingleElement(EnumSet<? extends Enum<?>> value) {
return value.size() == 1;
}
@Override
public final void serialize(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider) throws IOException
{
final int len = value.size();
if ((len == 1) && provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)) {
serializeContents(value, jgen, provider);
return;
}
jgen.writeStartArray(len);
serializeContents(value, jgen, provider);
jgen.writeEndArray();
}
@Override
public void serializeContents(EnumSet<? extends Enum<?>> value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
JsonSerializer<Object> enumSer = _elementSerializer;
/* Need to dynamically find instance serializer; unfortunately
* that seems to be the only way to figure out
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> ignoreAllUnknown);
}
protected BeanDeserializer(BeanDeserializerBase src, NameTransformer unwrapper) {
super(src, unwrapper);
}
public BeanDeserializer(BeanDeserializerBase src, ObjectIdReader oir) {
super(src, oir);
}
public BeanDeserializer(BeanDeserializerBase src, HashSet<String> ignorableProps) {
super(src, ignorableProps);
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper)
{
/* bit kludgy but we don't want to accidentally change type; sub-classes
* MUST override this method to support unwrapped properties...
*/
if (getClass() != BeanDeserializer.class) {
return this;
}
/* main thing really is to just enforce ignoring of unknown
* properties; since there may be multiple unwrapped values
* and properties for all may be interleaved...
*/
return new BeanDeserializer(this, unwrapper);
}
@Override
public BeanDeserializer withObjectIdReader(ObjectIdReader oir) {
return new BeanDeserializer(this, oir);
}
@Override
public BeanDeserializer withIgnorableProperties(HashSet<String> ignorableProps) {
return new BeanDeserializer(this, ignorableProps);
}
@Override
protected BeanDeserializerBase asArrayDeserializer() {
SettableBeanProperty[] props = _beanProperties.getPropertiesInInsertionOrder();
return new BeanAsArrayDeserializer(this, props);
}
/*
/**********************************************************
/* JsonDeserializer implementation
/**********************************************************
*/
/**
* Main deserialization method for bean-based objects (POJOs).
*<p>
* NOTE: was declared 'final' in 2.2; should NOT be to let extensions
* like Afterburner change definition.
*/
@Override
public Object deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException
{
JsonToken t = p.getCurrentToken();
// common case first
if (t == JsonToken.START_OBJECT) { // TODO: in 2.6, use 'p.hasTokenId()'
if (_vanillaProcessing) {
return vanillaDeserialize(p, ctxt, p.nextToken());
}
p.nextToken();
if (_objectIdReader != null) {
return deserializeWithObjectId(p, ctxt);
}
return
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Property(propName);
if (creatorProp != null) {
// Last creator property to set?
Object value = creatorProp.deserialize(p, ctxt);
if (buffer.assignParameter(creatorProp.getCreatorIndex(), value)) {
p.nextToken(); // to move to following FIELD_NAME/END_OBJECT
Object bean;
try {
bean = creator.build(ctxt, buffer);
} catch (Exception e) {
wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt);
bean = null; // never gets here
}
if (bean == null) {
throw ctxt.instantiationException(_beanType.getRawClass(), "JSON Creator returned null");
}
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(bean);
// polymorphic?
if (bean.getClass() != _beanType.getRawClass()) {
return handlePolymorphic(p, ctxt, bean, unknown);
}
if (unknown != null) { // nope, just extra unknown stuff...
bean = handleUnknownProperties(ctxt, bean, unknown);
}
// or just clean?
return deserialize(p, ctxt, bean);
}
continue;
}
// Object Id property?
if (buffer.readIdProperty(propName)) {
continue;
}
// regular property? needs buffering
SettableBeanProperty prop = _beanProperties.find(propName);
if (prop != null) {
buffer.bufferProperty(prop, prop.deserialize(p, ctxt));
continue;
}
// As per [JACKSON-313], things marked as ignorable should not be
// passed to any setter
if (_ignorableProps != null && _ignorableProps.contains(propName)) {
handleIgnoredProperty(p, ctxt, handledType(), propName);
continue;
}
// "any property"?
if (_anySetter != null) {
buffer.bufferAnyProperty(_anySetter, propName, _anySetter.deserialize(p, ctxt));
continue;
}
// Ok then, let's collect the whole field; name and value
if (unknown == null) {
unknown = new TokenBuffer(p);
}
unknown.writeFieldName(propName);
unknown
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>.copyCurrentStructure(p);
}
// We hit END_OBJECT, so:
Object bean;
try {
bean = creator.build(ctxt, buffer);
} catch (Exception e) {
wrapInstantiationProblem(e, ctxt);
bean = null; // never gets here
}
if (unknown != null) {
// polymorphic?
if (bean.getClass() != _beanType.getRawClass()) {
return handlePolymorphic(null, ctxt, bean, unknown);
}
// no, just some extra unknown properties
return handleUnknownProperties(ctxt, bean, unknown);
}
return bean;
}
/*
/**********************************************************
/* Deserializing when we have to consider an active View
/**********************************************************
*/
protected final Object deserializeWithView(JsonParser p, DeserializationContext ctxt,
Object bean, Class<?> activeView)
throws IOException
{
JsonToken t = p.getCurrentToken();
for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) {
String propName = p.getCurrentName();
// Skip field name:
p.nextToken();
SettableBeanProperty prop = _beanProperties.find(propName);
if (prop != null) {
if (!prop.visibleInView(activeView)) {
p.skipChildren();
continue;
}
try {
prop.deserializeAndSet(p, ctxt, bean);
} catch (Exception e) {
wrapAndThrow(e, bean, propName, ctxt);
}
continue;
}
handleUnknownVanilla(p, ctxt, bean, propName);
}
return bean;
}
/*
/**********************************************************
/* Handling for cases where we have "unwrapped" values
/**********************************************************
*/
/**
* Method called when there are declared "unwrapped" properties
* which need special handling
*/
@SuppressWarnings("resource")
protected Object deserializeWithUnwrapped(JsonParser p, DeserializationContext ctxt)
throws IOException
{
if (_delegateDeserializer != null) {
return _valueInstantiator.createUsingDelegate(ctxt, _delegateDeserializer.deserialize(p, ctxt));
}
if (_propertyBasedCreator != null) {
return deserializeUsingPropertyBasedWithUnwrapped(p, ctxt);
}
TokenBuffer tokens = new TokenBuffer(p);
tokens
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>_OBJECT
Object bean;
try {
bean = creator.build(ctxt, buffer);
} catch (Exception e) {
wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt);
continue; // never gets here
}
// [databind#631]: Assign current value, to be accessible by custom serializers
p.setCurrentValue(bean);
// if so, need to copy all remaining tokens into buffer
while (t == JsonToken.FIELD_NAME) {
p.nextToken(); // to skip name
tokens.copyCurrentStructure(p);
t = p.nextToken();
}
tokens.writeEndObject();
if (bean.getClass() != _beanType.getRawClass()) {
// !!! 08-Jul-2011, tatu: Could probably support; but for now
// it's too complicated, so bail out
tokens.close();
throw ctxt.mappingException("Can not create polymorphic instances with unwrapped values");
}
return _unwrappedPropertyHandler.processUnwrapped(p, ctxt, bean, tokens);
}
continue;
}
// Object Id property?
if (buffer.readIdProperty(propName)) {
continue;
}
// regular property? needs buffering
SettableBeanProperty prop = _beanProperties.find(propName);
if (prop != null) {
buffer.bufferProperty(prop, prop.deserialize(p, ctxt));
continue;
}
/* As per [JACKSON-313], things marked as ignorable should not be
* passed to any setter
*/
if (_ignorableProps != null && _ignorableProps.contains(propName)) {
handleIgnoredProperty(p, ctxt, handledType(), propName);
continue;
}
tokens.writeFieldName(propName);
tokens.copyCurrentStructure(p);
// "any property"?
if (_anySetter != null) {
buffer.bufferAnyProperty(_anySetter, propName, _anySetter.deserialize(p, ctxt));
}
}
// We hit END_OBJECT, so:
Object bean;
try {
bean = creator.build(ctxt, buffer);
} catch (Exception e) {
wrapInstantiationProblem(e, ctxt);
return null; // never gets here
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Exception e) {
wrapAndThrow(e, bean, propName, ctxt);
}
continue;
}
// Unknown: let's call handler method
handleUnknownProperty(p, ctxt, bean, propName);
}
// and when we get this far, let's try finalizing the deal:
return ext.complete(p, ctxt, bean);
}
@SuppressWarnings("resource")
protected Object deserializeUsingPropertyBasedWithExternalTypeId(JsonParser p, DeserializationContext ctxt)
throws IOException
{
final ExternalTypeHandler ext = _externalTypeIdHandler.start();
final PropertyBasedCreator creator = _propertyBasedCreator;
PropertyValueBuffer buffer = creator.startBuilding(p, ctxt, _objectIdReader);
TokenBuffer tokens = new TokenBuffer(p);
tokens.writeStartObject();
JsonToken t = p.getCurrentToken();
for (; t == JsonToken.FIELD_NAME; t = p.nextToken()) {
String propName = p.getCurrentName();
p.nextToken(); // to point to value
// creator property?
SettableBeanProperty creatorProp = creator.findCreatorProperty(propName);
if (creatorProp != null) {
// first: let's check to see if this might be part of value with external type id:
if (ext.handlePropertyValue(p, ctxt, propName, buffer)) {
;
} else {
// Last creator property to set?
Object value = creatorProp.deserialize(p, ctxt);
if (buffer.assignParameter(creatorProp.getCreatorIndex(), value)) {
t = p.nextToken(); // to move to following FIELD_NAME/END_OBJECT
Object bean;
try {
bean = creator.build(ctxt, buffer);
} catch (Exception e) {
wrapAndThrow(e, _beanType.getRawClass(), propName, ctxt);
continue; // never gets here
}
// if so, need to copy all remaining tokens into buffer
while (t == JsonToken.FIELD_NAME) {
p.nextToken(); // to skip name
tokens.copyCurrentStructure(p);
t = p.nextToken();
}
if (bean.getClass() != _beanType.getRawClass()) {
// !!! 08-Jul-2011, tatu: Could probably support; but for now
//
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.impl;
import java.io.IOException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
/**
* Simple serializer that will call configured type serializer, passing
* in configured data serializer, and exposing it all as a simple
* serializer.
*/
public final class TypeWrappedSerializer
extends JsonSerializer<Object>
{
final protected TypeSerializer _typeSerializer;
final protected JsonSerializer<Object> _serializer;
@SuppressWarnings("unchecked")
public TypeWrappedSerializer(TypeSerializer typeSer, JsonSerializer<?> ser)
{
super();
_typeSerializer = typeSer;
_serializer = (JsonSerializer<Object>) ser;
}
@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException {
_serializer.serializeWithType(value, jgen, provider, _typeSerializer);
}
@Override
public void serializeWithType(Object value, JsonGenerator jgen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
/* Is this an erroneous call? For now, let's assume it is not, and
* that type serializer is just overridden if so
*/
_serializer.serializeWithType(value, jgen, provider, typeSer);
}
@Override
public Class<Object> handledType() { return Object.class; }
/*
/**********************************************************
/* Extended API for other core classes
/**********************************************************
*/
public JsonSerializer<Object> valueSerializer() {
return _serializer;
}
public TypeSerializer typeSerializer() {
return _typeSerializer;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.format.InputAccessor;
import com.fasterxml.jackson.core.format.MatchStrength;
/**
* Sub-class of {@link JsonFactory} that will create a proper
* {@link ObjectCodec} to allow seam-less conversions between
* JSON content and Java objects (POJOs).
* The only addition to regular {@link JsonFactory} currently
* is that {@link ObjectMapper} is constructed and passed as
* the codec to use.
*/
public class MappingJsonFactory
extends JsonFactory
{
// generated for Jackson 2.1.0
private static final long serialVersionUID = -6744103724013275513L;
public MappingJsonFactory()
{
this(null);
}
public MappingJsonFactory(ObjectMapper mapper)
{
super(mapper);
if (mapper == null) {
setCodec(new ObjectMapper(this));
}
}
/**
* We'll override the method to return more specific type; co-variance
* helps here
*/
@Override
public final ObjectMapper getCodec() { return (ObjectMapper) _objectCodec; }
// @since 2.1
@Override
public JsonFactory copy()
{
_checkInvalidCopy(MappingJsonFactory.class);
// note: as with base class, must NOT copy mapper reference
return new MappingJsonFactory(null);
}
/*
/**********************************************************
/* Format detection functionality (since 1.8)
/**********************************************************
*/
/**
* Sub-classes need to override this method (as of 1.8)
*/
@Override
public String getFormatName()
{
/* since non-JSON factories typically should not extend this class,
* let's just always return JSON as name.
*/
return FORMAT_NAME_JSON;
}
/**
* Sub-classes need to override this method (as of 1.8)
*/
@Override
public MatchStrength hasFormat(InputAccessor acc) throws IOException
{
if (getClass() == MappingJsonFactory.class) {
return hasJSONFormat(acc);
}
return null;
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.ser.std;
import java.io.IOException;
import java.lang.reflect.Type;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JacksonStdImpl;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.util.TokenBuffer;
/**
* We also want to directly support serialization of {@link TokenBuffer};
* and since it is part of core package, it can not implement
* {@link com.fasterxml.jackson.databind.JsonSerializable}
* (which is only included in the mapper package)
*/
@JacksonStdImpl
@SuppressWarnings("serial")
public class TokenBufferSerializer
extends StdSerializer<TokenBuffer>
{
public TokenBufferSerializer() { super(TokenBuffer.class); }
@Override
public void serialize(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
value.serialize(jgen);
}
/**
* Implementing typed output for contents of a TokenBuffer is very tricky,
* since we do not know for sure what its contents might look like (or, rather,
* we do know when serializing, but not necessarily when deserializing!)
* One possibility would be to check the current token, and use that to
* determine if we would output JSON Array, Object or scalar value.
* Jackson 1.5 did NOT include any type information; but this seems wrong,
* and so 1.6 WILL include type information.
*<p>
* Note that we just claim it is scalar; this should work ok and is simpler
* than doing introspection on both serialization and deserialization.
*/
@Override
public final void serializeWithType(TokenBuffer value, JsonGenerator jgen, SerializerProvider provider,
TypeSerializer typeSer)
throws IOException, JsonGenerationException
{
typeSer.writeTypePrefixForScalar
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
/**********************************************************
*/
@Override
public int getParameterCount() {
return _constructor.getParameterTypes().length;
}
@Override
public Class<?> getRawParameterType(int index)
{
Class<?>[] types = _constructor.getParameterTypes();
return (index >= types.length) ? null : types[index];
}
@Override
public Type getGenericParameterType(int index)
{
Type[] types = _constructor.getGenericParameterTypes();
return (index >= types.length) ? null : types[index];
}
@Override
public final Object call() throws Exception {
return _constructor.newInstance();
}
@Override
public final Object call(Object[] args) throws Exception {
return _constructor.newInstance(args);
}
@Override
public final Object call1(Object arg) throws Exception {
return _constructor.newInstance(arg);
}
/*
/**********************************************************
/* AnnotatedMember impl
/**********************************************************
*/
@Override
public Class<?> getDeclaringClass() { return _constructor.getDeclaringClass(); }
@Override
public Member getMember() { return _constructor; }
@Override
public void setValue(Object pojo, Object value)
throws UnsupportedOperationException
{
throw new UnsupportedOperationException("Cannot call setValue() on constructor of "
+getDeclaringClass().getName());
}
@Override
public Object getValue(Object pojo)
throws UnsupportedOperationException
{
throw new UnsupportedOperationException("Cannot call getValue() on constructor of "
+getDeclaringClass().getName());
}
/*
/**********************************************************
/* Extended API, specific annotations
/**********************************************************
*/
@Override
public String toString() {
return "[constructor for "+getName()+", annotations: "+_annotations+"]";
}
@Override
public int hashCode() {
return _constructor.getName().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) return true;
if (o == null || o.getClass() != getClass()) return false;
return ((AnnotatedConstructor) o)._constructor == _constructor;
}
/*
/**********************************************************
/* JDK serialization handling
/**********************************************************
*/
Object writeReplace() {
return new AnnotatedConstructor(new Serialization(_constructor));
}
Object readResolve() {
Class<?> clazz = _serialization.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind;
import java.io.*;
import java.net.URL;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import java.util.concurrent.ConcurrentHashMap;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.core.type.ResolvedType;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.cfg.ContextAttributes;
import com.fasterxml.jackson.databind.deser.DataFormatReaders;
import com.fasterxml.jackson.databind.deser.DefaultDeserializationContext;
import com.fasterxml.jackson.databind.deser.DeserializationProblemHandler;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.NullNode;
import com.fasterxml.jackson.databind.node.TreeTraversingParser;
import com.fasterxml.jackson.databind.type.SimpleType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.RootNameLookup;
/**
* Builder object that can be used for per-serialization configuration of
* deserialization parameters, such as root type to use or object
* to update (instead of constructing new instance).
*<p>
* Uses "fluent" (or, kind of, builder) pattern so that instances are immutable
* (and thus fully thread-safe with no external synchronization);
* new instances are constructed for different configurations.
* Instances are initially constructed by {@link ObjectMapper} and can be
* reused, shared, cached; both because of thread-safety and because
* instances are relatively light-weight.
*/
public class ObjectReader
extends ObjectCodec
implements Versioned, java.io.Serializable // since 2.1
{
private static final long serialVersionUID = 1L; // since 2.5
private final static JavaType JSON_NODE_TYPE = SimpleType.constructUnsafe(JsonNode.class);
/*
/**********************************************************
/* Immutable configuration from ObjectMapper
/**********************************************************
*/
/**
* General serialization configuration settings; while immutable,
* can use copy-constructor to create modified instances as necessary.
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>Type(_config.constructType(valueType));
}
/**
* @deprecated since 2.5 Use {@link #forType(Class)} instead
*/
@Deprecated
public ObjectReader withType(java.lang.reflect.Type valueType) {
return forType(_config.getTypeFactory().constructType(valueType));
}
/**
* @deprecated since 2.5 Use {@link #forType(TypeReference)} instead
*/
@Deprecated
public ObjectReader withType(TypeReference<?> valueTypeRef) {
return forType(_config.getTypeFactory().constructType(valueTypeRef.getType()));
}
/**
* Method for constructing a new instance with configuration that
* updates passed Object (as root value), instead of constructing
* a new value.
*<p>
* Note that the method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*/
public ObjectReader withValueToUpdate(Object value)
{
if (value == _valueToUpdate) return this;
if (value == null) {
throw new IllegalArgumentException("cat not update null value");
}
JavaType t;
/* no real benefit from pre-fetching, as updating readers are much
* less likely to be reused, and value type may also be forced
* with a later chained call...
*/
if (_valueType == null) {
t = _config.constructType(value.getClass());
} else {
t = _valueType;
}
return _new(this, _config, t, _rootDeserializer, value,
_schema, _injectableValues, _dataFormatReaders);
}
/**
* Method for constructing a new instance with configuration that
* uses specified View for filtering.
*<p>
* Note that the method does NOT change state of this reader, but
* rather construct and returns a newly configured instance.
*/
public ObjectReader withView(Class<?> activeView) {
return _with(_config.withView(activeView));
}
public ObjectReader with(Locale l) {
return _with(_config.with(l));
}
public ObjectReader with(TimeZone tz) {
return _with(_config.with(tz));
}
public ObjectReader withHandler(DeserializationProblemHandler h) {
return _with(_config.withHandler
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> (may not be 'this')
return match.getReader()._bindAndClose(p, _valueToUpdate);
}
@SuppressWarnings("resource")
protected <T> MappingIterator<T> _detectBindAndReadValues(DataFormatReaders.Match match, boolean forceClosing)
throws IOException, JsonProcessingException
{
if (!match.hasMatch()) {
_reportUnkownFormat(_dataFormatReaders, match);
}
JsonParser p = match.createParserWithMatch();
// One more thing: we Own the input stream now; and while it's
// not super clean way to do it, we must ensure closure so:
if (forceClosing) {
p.enable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
}
// important: use matching ObjectReader (may not be 'this')
return match.getReader()._bindAndReadValues(p, _valueToUpdate);
}
@SuppressWarnings("resource")
protected JsonNode _detectBindAndCloseAsTree(InputStream in) throws IOException
{
DataFormatReaders.Match match = _dataFormatReaders.findFormat(in);
if (!match.hasMatch()) {
_reportUnkownFormat(_dataFormatReaders, match);
}
JsonParser p = match.createParserWithMatch();
p.enable(JsonParser.Feature.AUTO_CLOSE_SOURCE);
return match.getReader()._bindAndCloseAsTree(p);
}
/**
* Method called to indicate that format detection failed to detect format
* of given input
*/
protected void _reportUnkownFormat(DataFormatReaders detector, DataFormatReaders.Match match) throws JsonProcessingException
{
throw new JsonParseException("Can not detect format from input, does not look like any of detectable formats "
+detector.toString(),
JsonLocation.NA);
}
/*
/**********************************************************
/* Internal methods, other
/**********************************************************
*/
/**
* @since 2.2
*/
protected void _verifySchemaType(FormatSchema schema)
{
if (schema != null) {
if (!_parserFactory.canUseSchema(schema)) {
throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName()
+" for format "+_parserFactory.getFormatName());
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
}
/**
* Internal helper method called to create an instance of {@link DeserializationContext}
* for deserializing a single root value.
* Can be overridden if a custom context is needed.
*/
protected DefaultDeserializationContext createDeserializationContext(JsonParser jp,
DeserializationConfig cfg) {
// 04-Jan-2010, tatu: we do actually need the provider too... (for polymorphic deser)
return _context.createInstance(cfg, jp, _injectableValues);
}
protected void _reportUndetectableSource(Object src) throws JsonProcessingException
{
throw new JsonParseException("Can not use source of type "
+src.getClass().getName()+" with format auto-detection: must be byte- not char-based",
JsonLocation.NA);
}
protected InputStream _inputStream(URL src) throws IOException {
return src.openStream();
}
protected InputStream _inputStream(File f) throws IOException {
return new FileInputStream(f);
}
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> occurs if and only if the "value method" was annotated with
* {@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using}), otherwise
* null
*/
@SuppressWarnings("unchecked")
public JsonValueSerializer(Method valueMethod, JsonSerializer<?> ser)
{
super(valueMethod.getReturnType(), false);
_accessorMethod = valueMethod;
_valueSerializer = (JsonSerializer<Object>) ser;
_property = null;
_forceTypeInformation = true; // gets reconsidered when we are contextualized
}
@SuppressWarnings("unchecked")
public JsonValueSerializer(JsonValueSerializer src, BeanProperty property,
JsonSerializer<?> ser, boolean forceTypeInfo)
{
super(_notNullClass(src.handledType()));
_accessorMethod = src._accessorMethod;
_valueSerializer = (JsonSerializer<Object>) ser;
_property = property;
_forceTypeInformation = forceTypeInfo;
}
@SuppressWarnings("unchecked")
private final static Class<Object> _notNullClass(Class<?> cls) {
return (cls == null) ? Object.class : (Class<Object>) cls;
}
public JsonValueSerializer withResolved(BeanProperty property,
JsonSerializer<?> ser, boolean forceTypeInfo)
{
if (_property == property && _valueSerializer == ser
&& forceTypeInfo == _forceTypeInformation) {
return this;
}
return new JsonValueSerializer(this, property, ser, forceTypeInfo);
}
/*
/**********************************************************
/* Post-processing
/**********************************************************
*/
/**
* We can try to find the actual serializer for value, if we can
* statically figure out what the result type must be.
*/
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider,
BeanProperty property)
throws JsonMappingException
{
JsonSerializer<?> ser = _valueSerializer;
if (ser == null) {
/* Can only assign serializer statically if the declared type is final:
* if not, we don't really know the actual type until we get the instance.
*/
// 10-Mar-2010, tatu: Except if static typing is to be used
if (provider.isEnabled(MapperFeature.USE_STATIC_TYPING)
|| Modifier.isFinal(_accessorMethod.getReturnType().getModifiers())) {
JavaType
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> t = provider.constructType(_accessorMethod.getGenericReturnType());
// false -> no need to cache
/* 10-Mar-2010, tatu: Ideally we would actually separate out type
* serializer from value serializer; but, alas, there's no access
* to serializer factory at this point...
*/
// 05-Sep-2013, tatu: I _think_ this can be considered a primary property...
ser = provider.findPrimaryPropertySerializer(t, property);
/* 09-Dec-2010, tatu: Turns out we must add special handling for
* cases where "native" (aka "natural") type is being serialized,
* using standard serializer
*/
boolean forceTypeInformation = isNaturalTypeWithStdHandling(t.getRawClass(), ser);
return withResolved(property, ser, forceTypeInformation);
}
} else {
// 05-Sep-2013, tatu: I _think_ this can be considered a primary property...
ser = provider.handlePrimaryContextualization(ser, property);
return withResolved(property, ser, _forceTypeInformation);
}
return this;
}
/*
/**********************************************************
/* Actual serialization
/**********************************************************
*/
@Override
public void serialize(Object bean, JsonGenerator jgen, SerializerProvider prov) throws IOException
{
try {
Object value = _accessorMethod.invoke(bean);
if (value == null) {
prov.defaultSerializeNull(jgen);
return;
}
JsonSerializer<Object> ser = _valueSerializer;
if (ser == null) {
Class<?> c = value.getClass();
/* 10-Mar-2010, tatu: Ideally we would actually separate out type
* serializer from value serializer; but, alas, there's no access
* to serializer factory at this point...
*/
// let's cache it, may be needed soon again
ser = prov.findTypedValueSerializer(c, true, _property);
}
ser.serialize(value, jgen, prov);
} catch (IOException ioe) {
throw ioe;
} catch (Exception e) {
Throwable t = e;
// Need to unwrap this specific
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> type, to see infinite recursion...
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors shouldn't be wrapped (and often can't, as well)
if (t instanceof Error) {
throw (Error) t;
}
// let's try to indicate the path best we can...
throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()");
}
}
@Override
public void serializeWithType(Object bean, JsonGenerator jgen, SerializerProvider provider,
TypeSerializer typeSer0) throws IOException
{
// Regardless of other parts, first need to find value to serialize:
Object value = null;
try {
value = _accessorMethod.invoke(bean);
// and if we got null, can also just write it directly
if (value == null) {
provider.defaultSerializeNull(jgen);
return;
}
JsonSerializer<Object> ser = _valueSerializer;
if (ser == null) { // already got a serializer? fabulous, that be easy...
// ser = provider.findTypedValueSerializer(value.getClass(), true, _property);
ser = provider.findValueSerializer(value.getClass(), _property);
} else {
/* 09-Dec-2010, tatu: To work around natural type's refusal to add type info, we do
* this (note: type is for the wrapper type, not enclosed value!)
*/
if (_forceTypeInformation) {
typeSer0.writeTypePrefixForScalar(bean, jgen);
ser.serialize(value, jgen, provider);
typeSer0.writeTypeSuffixForScalar(bean, jgen);
return;
}
}
/* 13-Feb-2013, tatu: Turns out that work-around should NOT be required
* at all; it would not lead to correct behavior (as per #167).
*/
// and then redirect type id lookups
// TypeSerializer typeSer = new TypeSerializerWrapper(typeSer0, bean);
ser.serializeWithType(value, jgen, provider, typeSer0);
} catch (IOException ioe) {
throw ioe;
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> catch (Exception e) {
Throwable t = e;
// Need to unwrap this specific type, to see infinite recursion...
while (t instanceof InvocationTargetException && t.getCause() != null) {
t = t.getCause();
}
// Errors shouldn't be wrapped (and often can't, as well)
if (t instanceof Error) {
throw (Error) t;
}
// let's try to indicate the path best we can...
throw JsonMappingException.wrapWithPath(t, bean, _accessorMethod.getName() + "()");
}
}
@SuppressWarnings("deprecation")
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
if (_valueSerializer instanceof SchemaAware) {
return ((SchemaAware)_valueSerializer).getSchema(provider, null);
}
return com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode();
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonSerializer<Object> ser = _valueSerializer;
if (ser == null) {
if (typeHint == null) {
if (_property != null) {
typeHint = _property.getType();
}
if (typeHint == null) {
typeHint = visitor.getProvider().constructType(_accessorMethod.getReturnType());
}
}
ser = visitor.getProvider().findTypedValueSerializer(typeHint, false, _property);
if (ser == null) {
visitor.expectAnyFormat(typeHint);
return;
}
}
ser.acceptJsonFormatVisitor(visitor, null);
}
protected boolean isNaturalTypeWithStdHandling(Class<?> rawType, JsonSerializer<?> ser)
{
// First: do we have a natural type being handled?
if (rawType.isPrimitive()) {
if (rawType != Integer.TYPE && rawType != Boolean.TYPE && rawType != Double.TYPE) {
return false;
}
} else {
if (rawType != String.class &&
rawType != Integer.class && rawType != Boolean.class && rawType != Double.class) {
return false;
}
}
return isDefaultSerializer(ser);
}
/*
/**********************************************************
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>package com.fasterxml.jackson.databind.deser.std;
import java.io.IOException;
import com.fasterxml.jackson.core.*;
import com.fasterxml.jackson.databind.*;
import com.fasterxml.jackson.databind.deser.BeanDeserializer;
import com.fasterxml.jackson.databind.deser.SettableBeanProperty;
import com.fasterxml.jackson.databind.util.NameTransformer;
/**
* Deserializer that builds on basic {@link BeanDeserializer} but
* override some aspects like instance construction.
*/
public class ThrowableDeserializer
extends BeanDeserializer
{
private static final long serialVersionUID = 1L;
protected final static String PROP_NAME_MESSAGE = "message";
/*
/************************************************************
/* Construction
/************************************************************
*/
public ThrowableDeserializer(BeanDeserializer baseDeserializer) {
super(baseDeserializer);
// need to disable this, since we do post-processing
_vanillaProcessing = false;
}
/**
* Alternative constructor used when creating "unwrapping" deserializers
*/
protected ThrowableDeserializer(BeanDeserializer src, NameTransformer unwrapper) {
super(src, unwrapper);
}
@Override
public JsonDeserializer<Object> unwrappingDeserializer(NameTransformer unwrapper) {
if (getClass() != ThrowableDeserializer.class) {
return this;
}
/* main thing really is to just enforce ignoring of unknown
* properties; since there may be multiple unwrapped values
* and properties for all may be interleaved...
*/
return new ThrowableDeserializer(this, unwrapper);
}
/*
/************************************************************
/* Overridden methods
/************************************************************
*/
@Override
public Object deserializeFromObject(JsonParser jp, DeserializationContext ctxt) throws IOException
{
// 30-Sep-2010, tatu: Need to allow use of @JsonCreator, so:
if (_propertyBasedCreator != null) { // proper @JsonCreator
return _deserializeUsingPropertyBased(jp, ctxt);
}
if (_delegateDeserializer != null) {
return _valueInstantiator.createUsingDelegate(ctxt,
_delegateDeserializer.deserialize(jp, ctxt));
}
if (_beanType.isAbstract()) { // for good measure, check this too
throw JsonMappingException.from(jp, "Can not instantiate abstract type "+_bean
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>
public Iterator<JsonNode> elements() {
return _children.values().iterator();
}
@Override
public JsonNode get(int index) { return null; }
@Override
public JsonNode get(String fieldName) {
return _children.get(fieldName);
}
@Override
public Iterator<String> fieldNames() {
return _children.keySet().iterator();
}
@Override
public JsonNode path(int index) {
return MissingNode.getInstance();
}
@Override
public JsonNode path(String fieldName)
{
JsonNode n = _children.get(fieldName);
if (n != null) {
return n;
}
return MissingNode.getInstance();
}
/**
* Method to use for accessing all fields (with both names
* and values) of this JSON Object.
*/
@Override
public Iterator<Map.Entry<String, JsonNode>> fields() {
return _children.entrySet().iterator();
}
@Override
public ObjectNode with(String propertyName) {
JsonNode n = _children.get(propertyName);
if (n != null) {
if (n instanceof ObjectNode) {
return (ObjectNode) n;
}
throw new UnsupportedOperationException("Property '" + propertyName
+ "' has value that is not of type ObjectNode (but " + n
.getClass().getName() + ")");
}
ObjectNode result = objectNode();
_children.put(propertyName, result);
return result;
}
@Override
public ArrayNode withArray(String propertyName)
{
JsonNode n = _children.get(propertyName);
if (n != null) {
if (n instanceof ArrayNode) {
return (ArrayNode) n;
}
throw new UnsupportedOperationException("Property '" + propertyName
+ "' has value that is not of type ArrayNode (but " + n
.getClass().getName() + ")");
}
ArrayNode result = arrayNode();
_children.put(propertyName, result);
return result;
}
/*
/**********************************************************
/* Public API, finding value nodes
/**********************************************************
*/
@Override
public JsonNode findValue(String fieldName)
{
for (Map.Entry<String, JsonNode> entry : _children.entrySet()) {
if (fieldName.equals(entry.getKey())) {
return entry.getValue();
}
JsonNode value = entry
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> null) {
jgen.writeNull();
} else if (n instanceof String) {
jgen.writeNumber((String) n);
} else {
throw new JsonGenerationException("Unrecognized value type for VALUE_NUMBER_FLOAT: "+n.getClass().getName()+", can not serialize");
}
}
break;
case VALUE_TRUE:
jgen.writeBoolean(true);
break;
case VALUE_FALSE:
jgen.writeBoolean(false);
break;
case VALUE_NULL:
jgen.writeNull();
break;
case VALUE_EMBEDDED_OBJECT:
jgen.writeObject(segment.get(ptr));
break;
default:
throw new RuntimeException("Internal error: should never end up through this code path");
}
}
}
/**
* Helper method used by standard deserializer.
*
* @since 2.3
*/
public TokenBuffer deserialize(JsonParser jp, DeserializationContext ctxt) throws IOException
{
if (jp.getCurrentTokenId() != JsonToken.FIELD_NAME.id()) {
copyCurrentStructure(jp);
return this;
}
/* 28-Oct-2014, tatu: As per #592, need to support a special case of starting from
* FIELD_NAME, which is taken to mean that we are missing START_OBJECT, but need
* to assume one did exist.
*/
JsonToken t;
writeStartObject();
do {
copyCurrentStructure(jp);
} while ((t = jp.nextToken()) == JsonToken.FIELD_NAME);
if (t != JsonToken.END_OBJECT) {
throw ctxt.mappingException("Expected END_OBJECT after copying contents of a JsonParser into TokenBuffer, got "+t);
}
writeEndObject();
return this;
}
@Override
@SuppressWarnings("resource")
public String toString()
{
// Let's print up to 100 first tokens...
final int MAX_COUNT = 100;
StringBuilder sb = new StringBuilder();
sb.append("[TokenBuffer: ");
/*
sb.append("NativeTypeIds=").append(_hasNativeTypeIds).append(",");
sb.append("NativeObjectIds=").append(_hasNativeObjectIds).append(",");
*/
JsonParser
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS>(JsonToken.VALUE_NUMBER_FLOAT, encodedValue);
}
@Override
public void writeBoolean(boolean state) throws IOException,JsonGenerationException {
_append(state ? JsonToken.VALUE_TRUE : JsonToken.VALUE_FALSE);
}
@Override
public void writeNull() throws IOException, JsonGenerationException {
_append(JsonToken.VALUE_NULL);
}
/*
/***********************************************************
/* JsonGenerator implementation: write methods for POJOs/trees
/***********************************************************
*/
@Override
public void writeObject(Object value) throws IOException
{
if (value == null) {
writeNull();
return;
}
Class<?> raw = value.getClass();
if (raw == byte[].class) {
_append(JsonToken.VALUE_EMBEDDED_OBJECT, value);
return;
} else if (_objectCodec == null) {
/* 28-May-2014, tatu: Tricky choice here; if no codec, should we
* err out, or just embed? For now, do latter.
*/
// throw new JsonMappingException("No ObjectCodec configured for TokenBuffer, writeObject() called");
_append(JsonToken.VALUE_EMBEDDED_OBJECT, value);
} else {
_objectCodec.writeValue(this, value);
}
}
@Override
public void writeTree(TreeNode node) throws IOException
{
if (node == null) {
writeNull();
return;
}
if (_objectCodec == null) {
// as with 'writeObject()', is codec optional?
_append(JsonToken.VALUE_EMBEDDED_OBJECT, node);
} else {
_objectCodec.writeTree(this, node);
}
}
/*
/***********************************************************
/* JsonGenerator implementation; binary
/***********************************************************
*/
@Override
public void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len)
throws IOException, JsonGenerationException
{
/* 31-Dec-2009, tatu: can do this using multiple alternatives; but for
* now, let's try to limit number of conversions.
* The only (?) tricky thing is that of whether to preserve variant,
* seems pointless, so let
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> IOException, JsonParseException {
return getNumberValue().doubleValue();
}
@Override
public float getFloatValue() throws IOException, JsonParseException {
return getNumberValue().floatValue();
}
@Override
public int getIntValue() throws IOException, JsonParseException
{
// optimize common case:
if (_currToken == JsonToken.VALUE_NUMBER_INT) {
return ((Number) _currentObject()).intValue();
}
return getNumberValue().intValue();
}
@Override
public long getLongValue() throws IOException, JsonParseException {
return getNumberValue().longValue();
}
@Override
public NumberType getNumberType() throws IOException, JsonParseException
{
Number n = getNumberValue();
if (n instanceof Integer) return NumberType.INT;
if (n instanceof Long) return NumberType.LONG;
if (n instanceof Double) return NumberType.DOUBLE;
if (n instanceof BigDecimal) return NumberType.BIG_DECIMAL;
if (n instanceof BigInteger) return NumberType.BIG_INTEGER;
if (n instanceof Float) return NumberType.FLOAT;
if (n instanceof Short) return NumberType.INT; // should be SHORT
return null;
}
@Override
public final Number getNumberValue() throws IOException, JsonParseException {
_checkIsNumber();
Object value = _currentObject();
if (value instanceof Number) {
return (Number) value;
}
// Difficult to really support numbers-as-Strings; but let's try.
// NOTE: no access to DeserializationConfig, unfortunately, so can not
// try to determine Double/BigDecimal preference...
if (value instanceof String) {
String str = (String) value;
if (str.indexOf('.') >= 0) {
return Double.parseDouble(str);
}
return Long.parseLong(str);
}
if (value == null) {
return null;
}
throw new IllegalStateException("Internal error: entry should be a Number, but is of type "
+value.getClass().getName());
}
/*
/**********************************************************
/* Public API, access to token information, other
/**********************************************************
*/
@Override
public Object getEmbeddedObject()
{
if (_currToken == JsonToken.VALUE_EMBEDDED_OBJECT) {
return _currentObject();
}
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> if (ser == null) {
// 30-Sep-2012, tatu: One more thing -- if explicit content type is annotated,
// we can consider it a static case as well.
if (_elementType != null) {
// 20-Aug-2013, tatu: Need to avoid trying to access serializer for java.lang.Object tho
if ((_staticTyping && _elementType.getRawClass() != Object.class)
|| hasContentTypeAnnotation(provider, property)) {
ser = provider.findValueSerializer(_elementType, property);
}
}
} else {
ser = provider.handleSecondaryContextualization(ser, property);
}
if ((ser != _elementSerializer) || (property != _property) || _valueTypeSerializer != typeSer) {
return withResolved(property, typeSer, ser);
}
return this;
}
/*
/**********************************************************
/* Accessors
/**********************************************************
*/
@Override
public JavaType getContentType() {
return _elementType;
}
@Override
public JsonSerializer<?> getContentSerializer() {
return _elementSerializer;
}
/*
/**********************************************************
/* Serialization
/**********************************************************
*/
// NOTE: as of 2.5, sub-classes SHOULD override (in 2.4 and before, was final),
// at least if they can provide access to actual size of value and use `writeStartArray()`
// variant that passes size of array to output, which is helpful with some data formats
@Override
public void serialize(T value, JsonGenerator gen, SerializerProvider provider) throws IOException
{
if (provider.isEnabled(SerializationFeature.WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED)
&& hasSingleElement(value)) {
serializeContents(value, gen, provider);
return;
}
gen.writeStartArray();
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
serializeContents(value, gen, provider);
gen.writeEndArray();
}
@Override
public void serializeWithType(T value, JsonGenerator gen, SerializerProvider provider,
TypeSerializer typeSer) throws IOException
{
// note: let's NOT consider [JACKSON-805] here; gets too complicated,
JacksonDatabind, 15
<FILEB>
<CHANGES>
public final boolean isJavaLangObject() { return _class == Object.class; }
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (ser == null &&!delegateType.isJavaLangObject()) {
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
JsonSerializer<?> ser = delegateType.isJavaLangObject()? null
: provider.findValueSerializer(delegateType, prop);
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (!delegateType.isJavaLangObject()) {
<CHANGEE>
<CHANGES>
}
<CHANGEE>
<CHANGES>
if (delSer == _delegateSerializer && delegateType == _delegateType) {
return this;
}
return withDelegate(_converter, delegateType, delSer);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(delegateValue, provider);
}
ser.serialize(delegateValue, gen, provider);
<CHANGEE>
<CHANGES>
JsonSerializer<Object> ser = _delegateSerializer;
if (ser == null) {
ser = _findSerializer(value, provider);
}
ser.serializeWithType(delegateValue, gen, provider, typeSer);
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer == null) { // best we can do for now, too costly to look up
return (value == null);
}
<CHANGEE>
<CHANGES>
if (_delegateSerializer!= null) {
_delegateSerializer.acceptJsonFormatVisitor(visitor, typeHint);
}
<CHANGEE>
<CHANGES>
protected JsonSerializer<Object> _findSerializer(Object value, SerializerProvider serializers)
throws JsonMappingException
{
<CHANGEE>
<CHANGES>
return serializers.findValueSerializer(value.getClass());
}
<CHANGEE>
<FILEE>
<FILEB>
<CHANGES>
if (existingSerializer == null &&!delegateType.hasRawClass(Object.class)) {
<CHANGEE>
<FILEE>
<FILEB>
@Override
public boolean isCollectionLikeType() { return false; }
/**
* @return True if type is either true {@link java.util.Map} type,
* or something similar (meaning it has at least two type parameter;
* first one describing key type, second value type)
*/
@Override
public boolean isMapLikeType() { return false; }
/**
* Convenience method, short-hand for
*<code>
* getRawClass() == Object.class
*</code>
* and used to figure if we basically have "untyped" type object.
*
* @since 2.5
*/
<CHANGES>
<CHANGEE>
/**
* Accessor for checking whether handlers for dealing with values of
* this type should use static typing (as opposed to dynamic typing).
* Note that while value of 'true' does mean that static typing is to
* be used, value of 'false' may still be overridden by other settings.
*
* @since 2.2
*/
public final boolean useStaticType() { return _asStatic; }
/*
/**********************************************************
/* Public API, type parameter access; pass-through
<FILEE>
<FILEB>
staticTyping = true;
if (!type.hasRawClass(origType.getRawClass())) {
beanDesc = config.introspect(type);
}
}
// Slight detour: do we have a Converter to consider?
Converter<Object,Object> conv = beanDesc.findSerializationConverter();
if (conv == null) { // no, simple
return (JsonSerializer<Object>) _createSerializer2(prov, type, beanDesc, staticTyping);
}
JavaType delegateType = conv.getOutputType(prov.getTypeFactory());
// One more twist, as per [Issue#288]; probably need to get new BeanDesc
if (!delegateType.hasRawClass(type.getRawClass())) {
beanDesc = config.introspect(delegateType);
// [#359]: explicitly check (again) for @JsonSerializer...
ser = findSerializerFromAnnotation(prov, beanDesc.getClassInfo());
}
// [databind#731]: Should skip if nominally java.lang.Object
<CHANGES>
if (ser == null) {
<CHANGEE>
ser = _createSerializer2(<SCANS> and probably just won't work
typeSer.writeTypePrefixForArray(value, gen);
// [databind#631]: Assign current value, to be accessible by custom serializers
gen.setCurrentValue(value);
serializeContents(value, gen, provider);
typeSer.writeTypeSuffixForArray(value, gen);
}
protected abstract void serializeContents(T value, JsonGenerator gen, SerializerProvider provider)
throws IOException;
@SuppressWarnings("deprecation")
@Override
public JsonNode getSchema(SerializerProvider provider, Type typeHint)
throws JsonMappingException
{
ObjectNode o = createSchemaNode("array", true);
JavaType contentType = _elementType;
if (contentType != null) {
JsonNode schemaNode = null;
// 15-Oct-2010, tatu: We can't serialize plain Object.class; but what should it produce here? Untyped?
if (contentType.getRawClass() != Object.class) {
JsonSerializer<Object> ser = provider.findValueSerializer(contentType, _property);
if (ser instanceof SchemaAware) {
schemaNode = ((SchemaAware) ser).getSchema(provider, null);
}
}
if (schemaNode == null) {
schemaNode = com.fasterxml.jackson.databind.jsonschema.JsonSchema.getDefaultSchemaNode();
}
o.put("items", schemaNode);
}
return o;
}
@Override
public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
throws JsonMappingException
{
JsonArrayFormatVisitor arrayVisitor = (visitor == null) ? null : visitor.expectArrayFormat(typeHint);
if (arrayVisitor != null) {
/* 01-Sep-2014, tatu: Earlier was trying to make use of 'typeHint' for some
* reason, causing NPE (as per https://github.com/FasterXML/jackson-module-jsonSchema/issues/34)
* if coupled with `@JsonValue`. But I can't see much benefit of trying to rely
* on TypeHint here so code is simplified like so:
*/
JsonSerializer<?> valueSer = _elementSerializer;
if (valueSer == null) {
valueSer = visitor.getProvider().findValueSerializer(_elementType, _property);